(function () {
    'use strict';

    /*! DateTime picker for DataTables.net v0.0.8
	 *
	 * ©2020 SpryMedia Ltd, all rights reserved.
	 * License: MIT datatables.net/license/mit
	 */

    /**
     * @summary     DateTime picker for DataTables.net
     * @version     0.0.8
     * @file        dataTables.dateTime.js
     * @author      SpryMedia Ltd
     * @contact     www.datatables.net/contact
     */
    (function (factory) {
        if (typeof define === 'function' && define.amd) {
            // AMD
            define(['jquery'], function ($) {
                return factory($, window, document);
            });
        } else if (typeof exports === 'object') {
            // CommonJS
            module.exports = function (root, $) {
                if (!root) {
                    root = window;
                }

                return factory($, root, root.document);
            };
        } else {
            // Browser
            factory(jQuery, window, document);
        }
    }(function ($, window, document, undefined$1) {

        // Support libraries which support a Moment like API
        var dateLib = window.moment
            ? window.moment
            : window.dayjs
                ? window.dayjs
                : null;

        /*
	 * This file provides a DateTime GUI picker (calendar and time input). Only the
	 * format YYYY-MM-DD is supported without additional software, but the end user
	 * experience can be greatly enhanced by including the momentjs or dayjs library
	 * which provide date / time parsing and formatting options.
	 *
	 * This functionality is required because the HTML5 date and datetime input
	 * types are not widely supported in desktop browsers.
	 *
	 * Constructed by using:
	 *
	 *     new DateTime( input, opts )
	 *
	 * where `input` is the HTML input element to use and `opts` is an object of
	 * options based on the `DateTime.defaults` object.
	 */
        var DateTime = function (input, opts) {
            this.c = $.extend(true, {}, DateTime.defaults, opts);
            var classPrefix = this.c.classPrefix;
            var i18n = this.c.i18n;

            // Only IS8601 dates are supported without moment pr dayjs
            if (!dateLib && this.c.format !== 'YYYY-MM-DD') {
                throw "DateTime: Without momentjs or dayjs only the format 'YYYY-MM-DD' can be used";
            }

            // Min and max need to be `Date` objects in the config
            if (typeof this.c.minDate === 'string') {
                this.c.minDate = new Date(this.c.minDate);
            }
            if (typeof this.c.maxDate === 'string') {
                this.c.maxDate = new Date(this.c.maxDate);
            }

            // DOM structure
            var structure = $(
                '<div class="' + classPrefix + '">' +
                '<div class="' + classPrefix + '-date">' +
                '<div class="' + classPrefix + '-title">' +
                '<div class="' + classPrefix + '-iconLeft">' +
                '<button>' + i18n.previous + '</button>' +
                '</div>' +
                '<div class="' + classPrefix + '-iconRight">' +
                '<button>' + i18n.next + '</button>' +
                '</div>' +
                '<div class="' + classPrefix + '-label">' +
                '<span></span>' +
                '<select class="' + classPrefix + '-month"></select>' +
                '</div>' +
                '<div class="' + classPrefix + '-label">' +
                '<span></span>' +
                '<select class="' + classPrefix + '-year"></select>' +
                '</div>' +
                '</div>' +
                '<div class="' + classPrefix + '-calendar"></div>' +
                '</div>' +
                '<div class="' + classPrefix + '-time">' +
                '<div class="' + classPrefix + '-hours"></div>' +
                '<div class="' + classPrefix + '-minutes"></div>' +
                '<div class="' + classPrefix + '-seconds"></div>' +
                '</div>' +
                '<div class="' + classPrefix + '-error"></div>' +
                '</div>'
            );

            this.dom = {
                container: structure,
                date: structure.find('.' + classPrefix + '-date'),
                title: structure.find('.' + classPrefix + '-title'),
                calendar: structure.find('.' + classPrefix + '-calendar'),
                time: structure.find('.' + classPrefix + '-time'),
                error: structure.find('.' + classPrefix + '-error'),
                input: $(input)
            };

            this.s = {
                /** @type {Date} Date value that the picker has currently selected */
                d: null,

                /** @type {Date} Date of the calendar - might not match the value */
                display: null,

                /** @type {number} Used to select minutes in a range where the range base is itself unavailable */
                minutesRange: null,

                /** @type {number} Used to select minutes in a range where the range base is itself unavailable */
                secondsRange: null,

                /** @type {String} Unique namespace string for this instance */
                namespace: 'dateime-' + (DateTime._instance++),

                /** @type {Object} Parts of the picker that should be shown */
                parts: {
                    date: this.c.format.match(/[YMD]|L(?!T)|l/) !== null,
                    time: this.c.format.match(/[Hhm]|LT|LTS/) !== null,
                    seconds: this.c.format.indexOf('s') !== -1,
                    hours12: this.c.format.match(/[haA]/) !== null
                }
            };

            this.dom.container
                .append(this.dom.date)
                .append(this.dom.time)
                .append(this.dom.error);

            this.dom.date
                .append(this.dom.title)
                .append(this.dom.calendar);

            this._constructor();
        };

        $.extend(DateTime.prototype, {
            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Public
		 */

            /**
             * Destroy the control
             */
            destroy: function () {
                this._hide();
                this.dom.container.off().empty();
                this.dom.input.off('.datetime');
            },

            errorMsg: function (msg) {
                var error = this.dom.error;

                if (msg) {
                    error.html(msg);
                } else {
                    error.empty();
                }

                return this;
            },

            hide: function () {
                this._hide();

                return this;
            },

            max: function (date) {
                this.c.maxDate = typeof date === 'string'
                    ? new Date(date)
                    : date;

                this._optionsTitle();
                this._setCalander();

                return this;
            },

            min: function (date) {
                this.c.minDate = typeof date === 'string'
                    ? new Date(date)
                    : date;

                this._optionsTitle();
                this._setCalander();

                return this;
            },

            /**
             * Check if an element belongs to this control
             *
             * @param  {node} node Element to check
             * @return {boolean}   true if owned by this control, false otherwise
             */
            owns: function (node) {
                return $(node).parents().filter(this.dom.container).length > 0;
            },

            /**
             * Get / set the value
             *
             * @param  {string|Date} set   Value to set
             * @param  {boolean} [write=true] Flag to indicate if the formatted value
             *   should be written into the input element
             */
            val: function (set, write) {
                if (set === undefined$1) {
                    return this.s.d;
                }

                if (set instanceof Date) {
                    this.s.d = this._dateToUtc(set);
                } else if (set === null || set === '') {
                    this.s.d = null;
                } else if (set === '--now') {
                    this.s.d = new Date();
                } else if (typeof set === 'string') {
                    if (dateLib) {
                        // Use moment or dayjs if possible (even for ISO8601 strings, since it
                        // will correctly handle 0000-00-00 and the like)
                        var m = dateLib.utc(set, this.c.format, this.c.locale, this.c.strict);
                        this.s.d = m.isValid() ? m.toDate() : null;
                    } else {
                        // Else must be using ISO8601 without a date library (constructor would
                        // have thrown an error otherwise)
                        var match = set.match(/(\d{4})\-(\d{2})\-(\d{2})/);
                        this.s.d = match ?
                            new Date(Date.UTC(match[1], match[2] - 1, match[3])) :
                            null;
                    }
                }

                if (write || write === undefined$1) {
                    if (this.s.d) {
                        this._writeOutput();
                    } else {
                        // The input value was not valid...
                        this.dom.input.val(set);
                    }
                }

                // We need a date to be able to display the calendar at all
                if (!this.s.d) {
                    this.s.d = this._dateToUtc(new Date());
                }

                this.s.display = new Date(this.s.d.toString());

                // Set the day of the month to be 1 so changing between months doesn't
                // run into issues when going from day 31 to 28 (for example)
                this.s.display.setUTCDate(1);

                // Update the display elements for the new value
                this._setTitle();
                this._setCalander();
                this._setTime();

                return this;
            },


            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Constructor
		 */

            /**
             * Build the control and assign initial event handlers
             *
             * @private
             */
            _constructor: function () {
                var that = this;
                var classPrefix = this.c.classPrefix;
                var onChange = function () {
                    that.c.onChange.call(that, that.dom.input.val(), that.s.d, that.dom.input);
                };

                if (!this.s.parts.date) {
                    this.dom.date.css('display', 'none');
                }

                if (!this.s.parts.time) {
                    this.dom.time.css('display', 'none');
                }

                if (!this.s.parts.seconds) {
                    this.dom.time.children('div.' + classPrefix + '-seconds').remove();
                    this.dom.time.children('span').eq(1).remove();
                }

                // Render the options
                this._optionsTitle();

                // Trigger the display of the widget when clicking or focusing on the
                // input element
                this.dom.input
                    .attr('autocomplete', 'off')
                    .on('focus.datetime click.datetime', function () {
                        // If already visible - don't do anything
                        if (that.dom.container.is(':visible') || that.dom.input.is(':disabled')) {
                            return;
                        }

                        // In case the value has changed by text
                        that.val(that.dom.input.val(), false);

                        that._show();
                    })
                    .on('keyup.datetime', function () {
                        // Update the calendar's displayed value as the user types
                        if (that.dom.container.is(':visible')) {
                            that.val(that.dom.input.val(), false);
                        }
                    });

                // Main event handlers for input in the widget
                this.dom.container
                    .on('change', 'select', function () {
                        var select = $(this);
                        var val = select.val();

                        if (select.hasClass(classPrefix + '-month')) {
                            // Month select
                            that._correctMonth(that.s.display, val);
                            that._setTitle();
                            that._setCalander();
                        } else if (select.hasClass(classPrefix + '-year')) {
                            // Year select
                            that.s.display.setUTCFullYear(val);
                            that._setTitle();
                            that._setCalander();
                        } else if (select.hasClass(classPrefix + '-hours') || select.hasClass(classPrefix + '-ampm')) {
                            // Hours - need to take account of AM/PM input if present
                            if (that.s.parts.hours12) {
                                var hours = $(that.dom.container).find('.' + classPrefix + '-hours').val() * 1;
                                var pm = $(that.dom.container).find('.' + classPrefix + '-ampm').val() === 'pm';

                                that.s.d.setUTCHours(hours === 12 && !pm ?
                                    0 :
                                    pm && hours !== 12 ?
                                        hours + 12 :
                                        hours
                                );
                            } else {
                                that.s.d.setUTCHours(val);
                            }

                            that._setTime();
                            that._writeOutput(true);

                            onChange();
                        } else if (select.hasClass(classPrefix + '-minutes')) {
                            // Minutes select
                            that.s.d.setUTCMinutes(val);
                            that._setTime();
                            that._writeOutput(true);

                            onChange();
                        } else if (select.hasClass(classPrefix + '-seconds')) {
                            // Seconds select
                            that.s.d.setSeconds(val);
                            that._setTime();
                            that._writeOutput(true);

                            onChange();
                        }

                        that.dom.input.focus();
                        that._position();
                    })
                    .on('click', function (e) {
                        var d = that.s.d;
                        var nodeName = e.target.nodeName.toLowerCase();
                        var target = nodeName === 'span' ?
                            e.target.parentNode :
                            e.target;

                        nodeName = target.nodeName.toLowerCase();

                        if (nodeName === 'select') {
                            return;
                        }

                        e.stopPropagation();

                        if (nodeName === 'button') {
                            var button = $(target);
                            var parent = button.parent();

                            if (parent.hasClass('disabled') && !parent.hasClass('range')) {
                                button.blur();
                                return;
                            }

                            if (parent.hasClass(classPrefix + '-iconLeft')) {
                                // Previous month
                                that.s.display.setUTCMonth(that.s.display.getUTCMonth() - 1);
                                that._setTitle();
                                that._setCalander();

                                that.dom.input.focus();
                            } else if (parent.hasClass(classPrefix + '-iconRight')) {
                                // Next month
                                that._correctMonth(that.s.display, that.s.display.getUTCMonth() + 1);
                                that._setTitle();
                                that._setCalander();

                                that.dom.input.focus();
                            } else if (button.parents('.' + classPrefix + '-time').length) {
                                var val = button.data('value');
                                var unit = button.data('unit');

                                if (unit === 'minutes') {
                                    if (parent.hasClass('disabled') && parent.hasClass('range')) {
                                        that.s.minutesRange = val;
                                        that._setTime();
                                        return;
                                    } else {
                                        that.s.minutesRange = null;
                                    }
                                }

                                if (unit === 'seconds') {
                                    if (parent.hasClass('disabled') && parent.hasClass('range')) {
                                        that.s.secondsRange = val;
                                        that._setTime();
                                        return;
                                    } else {
                                        that.s.secondsRange = null;
                                    }
                                }

                                // Specific to hours for 12h clock
                                if (val === 'am') {
                                    if (d.getUTCHours() >= 12) {
                                        val = d.getUTCHours() - 12;
                                    } else {
                                        return;
                                    }
                                } else if (val === 'pm') {
                                    if (d.getUTCHours() < 12) {
                                        val = d.getUTCHours() + 12;
                                    } else {
                                        return;
                                    }
                                }

                                var set = unit === 'hours' ?
                                    'setUTCHours' :
                                    unit === 'minutes' ?
                                        'setUTCMinutes' :
                                        'setSeconds';

                                d[set](val);
                                that._setTime();
                                that._writeOutput(true);
                                onChange();
                            } else {
                                // Calendar click
                                if (!d) {
                                    d = that._dateToUtc(new Date());
                                }

                                // Can't be certain that the current day will exist in
                                // the new month, and likewise don't know that the
                                // new day will exist in the old month, But 1 always
                                // does, so we can change the month without worry of a
                                // recalculation being done automatically by `Date`
                                d.setUTCDate(1);
                                d.setUTCFullYear(button.data('year'));
                                d.setUTCMonth(button.data('month'));
                                d.setUTCDate(button.data('day'));

                                that._writeOutput(true);

                                // Don't hide if there is a time picker, since we want to
                                // be able to select a time as well.
                                if (!that.s.parts.time) {
                                    // This is annoying but IE has some kind of async
                                    // behaviour with focus and the focus from the above
                                    // write would occur after this hide - resulting in the
                                    // calendar opening immediately
                                    setTimeout(function () {
                                        that._hide();
                                    }, 10);
                                } else {
                                    that._setCalander();
                                }

                                onChange();
                            }
                        } else {
                            // Click anywhere else in the widget - return focus to the
                            // input element
                            that.dom.input.focus();
                        }
                    });
            },


            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Private
		 */

            /**
             * Compare the date part only of two dates - this is made super easy by the
             * toDateString method!
             *
             * @param  {Date} a Date 1
             * @param  {Date} b Date 2
             * @private
             */
            _compareDates: function (a, b) {
                // Can't use toDateString as that converts to local time
                return this._dateToUtcString(a) === this._dateToUtcString(b);
            },

            /**
             * When changing month, take account of the fact that some months don't have
             * the same number of days. For example going from January to February you
             * can have the 31st of Jan selected and just add a month since the date
             * would still be 31, and thus drop you into March.
             *
             * @param  {Date} date  Date - will be modified
             * @param  {integer} month Month to set
             * @private
             */
            _correctMonth: function (date, month) {
                var days = this._daysInMonth(date.getUTCFullYear(), month);
                var correctDays = date.getUTCDate() > days;

                date.setUTCMonth(month);

                if (correctDays) {
                    date.setUTCDate(days);
                    date.setUTCMonth(month);
                }
            },

            /**
             * Get the number of days in a method. Based on
             * http://stackoverflow.com/a/4881951 by Matti Virkkunen
             *
             * @param  {integer} year  Year
             * @param  {integer} month Month (starting at 0)
             * @private
             */
            _daysInMonth: function (year, month) {
                //
                var isLeap = ((year % 4) === 0 && ((year % 100) !== 0 || (year % 400) === 0));
                var months = [31, (isLeap ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

                return months[month];
            },

            /**
             * Create a new date object which has the UTC values set to the local time.
             * This allows the local time to be used directly for the library which
             * always bases its calculations and display on UTC.
             *
             * @param  {Date} s Date to "convert"
             * @return {Date}   Shifted date
             */
            _dateToUtc: function (s) {
                return new Date(Date.UTC(
                    s.getFullYear(), s.getMonth(), s.getDate(),
                    s.getHours(), s.getMinutes(), s.getSeconds()
                ));
            },

            /**
             * Create a UTC ISO8601 date part from a date object
             *
             * @param  {Date} d Date to "convert"
             * @return {string} ISO formatted date
             */
            _dateToUtcString: function (d) {
                return d.getUTCFullYear() + '-' +
                    this._pad(d.getUTCMonth() + 1) + '-' +
                    this._pad(d.getUTCDate());
            },

            /**
             * Hide the control and remove events related to its display
             *
             * @private
             */
            _hide: function () {
                var namespace = this.s.namespace;

                this.dom.container.detach();

                $(window).off('.' + namespace);
                $(document).off('keydown.' + namespace);
                $('div.dataTables_scrollBody').off('scroll.' + namespace);
                $('div.DTE_Body_Content').off('scroll.' + namespace);
                $('body').off('click.' + namespace);
            },

            /**
             * Convert a 24 hour value to a 12 hour value
             *
             * @param  {integer} val 24 hour value
             * @return {integer}     12 hour value
             * @private
             */
            _hours24To12: function (val) {
                return val === 0 ?
                    12 :
                    val > 12 ?
                        val - 12 :
                        val;
            },

            /**
             * Generate the HTML for a single day in the calendar - this is basically
             * and HTML cell with a button that has data attributes so we know what was
             * clicked on (if it is clicked on) and a bunch of classes for styling.
             *
             * @param  {object} day Day object from the `_htmlMonth` method
             * @return {string}     HTML cell
             */
            _htmlDay: function (day) {
                if (day.empty) {
                    return '<td class="empty"></td>';
                }

                var classes = ['selectable'];
                var classPrefix = this.c.classPrefix;

                if (day.disabled) {
                    classes.push('disabled');
                }

                if (day.today) {
                    classes.push('now');
                }

                if (day.selected) {
                    classes.push('selected');
                }

                return '<td data-day="' + day.day + '" class="' + classes.join(' ') + '">' +
                    '<button class="' + classPrefix + '-button ' + classPrefix + '-day" type="button" ' + 'data-year="' + day.year + '" data-month="' + day.month + '" data-day="' + day.day + '">' +
                    '<span>' + day.day + '</span>' +
                    '</button>' +
                    '</td>';
            },


            /**
             * Create the HTML for a month to be displayed in the calendar table.
             *
             * Based upon the logic used in Pikaday - MIT licensed
             * Copyright (c) 2014 David Bushell
             * https://github.com/dbushell/Pikaday
             *
             * @param  {integer} year  Year
             * @param  {integer} month Month (starting at 0)
             * @return {string} Calendar month HTML
             * @private
             */
            _htmlMonth: function (year, month) {
                var now = this._dateToUtc(new Date()),
                    days = this._daysInMonth(year, month),
                    before = new Date(Date.UTC(year, month, 1)).getUTCDay(),
                    data = [],
                    row = [];

                if (this.c.firstDay > 0) {
                    before -= this.c.firstDay;

                    if (before < 0) {
                        before += 7;
                    }
                }

                var cells = days + before,
                    after = cells;

                while (after > 7) {
                    after -= 7;
                }

                cells += 7 - after;

                var minDate = this.c.minDate;
                var maxDate = this.c.maxDate;

                if (minDate) {
                    minDate.setUTCHours(0);
                    minDate.setUTCMinutes(0);
                    minDate.setSeconds(0);
                }

                if (maxDate) {
                    maxDate.setUTCHours(23);
                    maxDate.setUTCMinutes(59);
                    maxDate.setSeconds(59);
                }

                for (var i = 0, r = 0; i < cells; i++) {
                    var day = new Date(Date.UTC(year, month, 1 + (i - before))),
                        selected = this.s.d ? this._compareDates(day, this.s.d) : false,
                        today = this._compareDates(day, now),
                        empty = i < before || i >= (days + before),
                        disabled = (minDate && day < minDate) ||
                            (maxDate && day > maxDate);

                    var disableDays = this.c.disableDays;
                    if ($.isArray(disableDays) && $.inArray(day.getUTCDay(), disableDays) !== -1) {
                        disabled = true;
                    } else if (typeof disableDays === 'function' && disableDays(day) === true) {
                        disabled = true;
                    }

                    var dayConfig = {
                        day: 1 + (i - before),
                        month: month,
                        year: year,
                        selected: selected,
                        today: today,
                        disabled: disabled,
                        empty: empty
                    };

                    row.push(this._htmlDay(dayConfig));

                    if (++r === 7) {
                        if (this.c.showWeekNumber) {
                            row.unshift(this._htmlWeekOfYear(i - before, month, year));
                        }

                        data.push('<tr>' + row.join('') + '</tr>');
                        row = [];
                        r = 0;
                    }
                }

                var classPrefix = this.c.classPrefix;
                var className = classPrefix + '-table';
                if (this.c.showWeekNumber) {
                    className += ' weekNumber';
                }

                // Show / hide month icons based on min/max
                if (minDate) {
                    var underMin = minDate >= new Date(Date.UTC(year, month, 1, 0, 0, 0));

                    this.dom.title.find('div.' + classPrefix + '-iconLeft')
                        .css('display', underMin ? 'none' : 'block');
                }

                if (maxDate) {
                    var overMax = maxDate < new Date(Date.UTC(year, month + 1, 1, 0, 0, 0));

                    this.dom.title.find('div.' + classPrefix + '-iconRight')
                        .css('display', overMax ? 'none' : 'block');
                }

                return '<table class="' + className + '">' +
                    '<thead>' +
                    this._htmlMonthHead() +
                    '</thead>' +
                    '<tbody>' +
                    data.join('') +
                    '</tbody>' +
                    '</table>';
            },

            /**
             * Create the calendar table's header (week days)
             *
             * @return {string} HTML cells for the row
             * @private
             */
            _htmlMonthHead: function () {
                var a = [];
                var firstDay = this.c.firstDay;
                var i18n = this.c.i18n;

                // Take account of the first day shift
                var dayName = function (day) {
                    day += firstDay;

                    while (day >= 7) {
                        day -= 7;
                    }

                    return i18n.weekdays[day];
                };

                // Empty cell in the header
                if (this.c.showWeekNumber) {
                    a.push('<th></th>');
                }

                for (var i = 0; i < 7; i++) {
                    a.push('<th>' + dayName(i) + '</th>');
                }

                return a.join('');
            },

            /**
             * Create a cell that contains week of the year - ISO8601
             *
             * Based on https://stackoverflow.com/questions/6117814/ and
             * http://techblog.procurios.nl/k/n618/news/view/33796/14863/
             *
             * @param  {integer} d Day of month
             * @param  {integer} m Month of year (zero index)
             * @param  {integer} y Year
             * @return {string}
             * @private
             */
            _htmlWeekOfYear: function (d, m, y) {
                var date = new Date(y, m, d, 0, 0, 0, 0);

                // First week of the year always has 4th January in it
                date.setDate(date.getDate() + 4 - (date.getDay() || 7));

                var oneJan = new Date(y, 0, 1);
                var weekNum = Math.ceil((((date - oneJan) / 86400000) + 1) / 7);

                return '<td class="' + this.c.classPrefix + '-week">' + weekNum + '</td>';
            },

            /**
             * Create option elements from a range in an array
             *
             * @param  {string} selector Class name unique to the select element to use
             * @param  {array} values   Array of values
             * @param  {array} [labels] Array of labels. If given must be the same
             *   length as the values parameter.
             * @private
             */
            _options: function (selector, values, labels) {
                if (!labels) {
                    labels = values;
                }

                var select = this.dom.container.find('select.' + this.c.classPrefix + '-' + selector);
                select.empty();

                for (var i = 0, ien = values.length; i < ien; i++) {
                    select.append('<option value="' + values[i] + '">' + labels[i] + '</option>');
                }
            },

            /**
             * Set an option and update the option's span pair (since the select element
             * has opacity 0 for styling)
             *
             * @param  {string} selector Class name unique to the select element to use
             * @param  {*}      val      Value to set
             * @private
             */
            _optionSet: function (selector, val) {
                var select = this.dom.container.find('select.' + this.c.classPrefix + '-' + selector);
                var span = select.parent().children('span');

                select.val(val);

                var selected = select.find('option:selected');
                span.html(selected.length !== 0 ?
                    selected.text() :
                    this.c.i18n.unknown
                );
            },

            /**
             * Create time options list.
             *
             * @param  {string} unit Time unit - hours, minutes or seconds
             * @param  {integer} count Count range - 12, 24 or 60
             * @param  {integer} val Existing value for this unit
             * @param  {integer[]} allowed Values allow for selection
             * @param  {integer} range Override range
             * @private
             */
            _optionsTime: function (unit, count, val, allowed, range) {
                var classPrefix = this.c.classPrefix;
                var container = this.dom.container.find('div.' + classPrefix + '-' + unit);
                var i, j;
                var render = count === 12 ?
                    function (i) {
                        return i;
                    } :
                    this._pad;
                var classPrefix = this.c.classPrefix;
                var className = classPrefix + '-table';
                var i18n = this.c.i18n;

                if (!container.length) {
                    return;
                }

                var a = '';
                var span = 10;
                var button = function (value, label, className) {
                    // Shift the value for PM
                    if (count === 12 && val >= 12 && typeof value === 'number') {
                        value += 12;
                    }

                    var selected = val === value || (value === 'am' && val < 12) || (value === 'pm' && val >= 12) ?
                        'selected' :
                        '';

                    if (allowed && $.inArray(value, allowed) === -1) {
                        selected += ' disabled';
                    }

                    if (className) {
                        selected += ' ' + className;
                    }

                    return '<td class="selectable ' + selected + '">' +
                        '<button class="' + classPrefix + '-button ' + classPrefix + '-day" type="button" data-unit="' + unit + '" data-value="' + value + '">' +
                        '<span>' + label + '</span>' +
                        '</button>' +
                        '</td>';
                };

                if (count === 12) {
                    // Hours with AM/PM
                    a += '<tr>';

                    for (i = 1; i <= 6; i++) {
                        a += button(i, render(i));
                    }
                    a += button('am', i18n.amPm[0]);

                    a += '</tr>';
                    a += '<tr>';

                    for (i = 7; i <= 12; i++) {
                        a += button(i, render(i));
                    }
                    a += button('pm', i18n.amPm[1]);
                    a += '</tr>';

                    span = 7;
                } else if (count === 24) {
                    // Hours - 24
                    var c = 0;
                    for (j = 0; j < 4; j++) {
                        a += '<tr>';
                        for (i = 0; i < 6; i++) {
                            a += button(c, render(c));
                            c++;
                        }
                        a += '</tr>';
                    }

                    span = 6;
                } else {
                    // Minutes and seconds
                    a += '<tr>';
                    for (j = 0; j < 60; j += 10) {
                        a += button(j, render(j), 'range');
                    }
                    a += '</tr>';

                    // Slight hack to allow for the different number of columns
                    a += '</tbody></thead><table class="' + className + ' ' + className + '-nospace"><tbody>';

                    var start = range !== null ?
                        range :
                        Math.floor(val / 10) * 10;

                    a += '<tr>';
                    for (j = start + 1; j < start + 10; j++) {
                        a += button(j, render(j));
                    }
                    a += '</tr>';

                    span = 6;
                }

                container
                    .empty()
                    .append(
                        '<table class="' + className + '">' +
                        '<thead><tr><th colspan="' + span + '">' +
                        i18n[unit] +
                        '</th></tr></thead>' +
                        '<tbody>' +
                        a +
                        '</tbody>' +
                        '</table>'
                    );
            },

            /**
             * Create the options for the month and year
             *
             * @param  {integer} year  Year
             * @param  {integer} month Month (starting at 0)
             * @private
             */
            _optionsTitle: function () {
                var i18n = this.c.i18n;
                var min = this.c.minDate;
                var max = this.c.maxDate;
                var minYear = min ? min.getFullYear() : null;
                var maxYear = max ? max.getFullYear() : null;

                var i = minYear !== null ? minYear : new Date().getFullYear() - this.c.yearRange;
                var j = maxYear !== null ? maxYear : new Date().getFullYear() + this.c.yearRange;

                this._options('month', this._range(0, 11), i18n.months);
                this._options('year', this._range(i, j));
            },

            /**
             * Simple two digit pad
             *
             * @param  {integer} i      Value that might need padding
             * @return {string|integer} Padded value
             * @private
             */
            _pad: function (i) {
                return i < 10 ? '0' + i : i;
            },

            /**
             * Position the calendar to look attached to the input element
             * @private
             */
            _position: function () {
                var offset = this.c.attachTo === 'input' ? this.dom.input.position() : this.dom.input.offset();
                var container = this.dom.container;
                var inputHeight = this.dom.input.outerHeight();

                if (this.s.parts.date && this.s.parts.time && $(window).width() > 550) {
                    container.addClass('horizontal');
                } else {
                    container.removeClass('horizontal');
                }

                if (this.c.attachTo === 'input') {
                    container
                        .css({
                            top: offset.top + inputHeight,
                            left: offset.left
                        })
                        .insertAfter(this.dom.input);
                } else {
                    container
                        .css({
                            top: offset.top + inputHeight,
                            left: offset.left
                        })
                        .appendTo('body');
                }

                var calHeight = container.outerHeight();
                var calWidth = container.outerWidth();
                var scrollTop = $(window).scrollTop();

                // Correct to the bottom
                if (offset.top + inputHeight + calHeight - scrollTop > $(window).height()) {
                    var newTop = offset.top - calHeight;

                    container.css('top', newTop < 0 ? 0 : newTop);
                }

                // Correct to the right
                if (calWidth + offset.left > $(window).width()) {
                    var newLeft = $(window).width() - calWidth;

                    container.css('left', newLeft < 0 ? 0 : newLeft);
                }
            },

            /**
             * Create a simple array with a range of values
             *
             * @param  {integer} start   Start value (inclusive)
             * @param  {integer} end     End value (inclusive)
             * @param  {integer} [inc=1] Increment value
             * @return {array}           Created array
             * @private
             */
            _range: function (start, end, inc) {
                var a = [];

                if (!inc) {
                    inc = 1;
                }

                for (var i = start; i <= end; i += inc) {
                    a.push(i);
                }

                return a;
            },

            /**
             * Redraw the calendar based on the display date - this is a destructive
             * operation
             *
             * @private
             */
            _setCalander: function () {
                if (this.s.display) {
                    this.dom.calendar
                        .empty()
                        .append(this._htmlMonth(
                            this.s.display.getUTCFullYear(),
                            this.s.display.getUTCMonth()
                        ));
                }
            },

            /**
             * Set the month and year for the calendar based on the current display date
             *
             * @private
             */
            _setTitle: function () {
                this._optionSet('month', this.s.display.getUTCMonth());
                this._optionSet('year', this.s.display.getUTCFullYear());
            },

            /**
             * Set the time based on the current value of the widget
             *
             * @private
             */
            _setTime: function () {
                var that = this;
                var d = this.s.d;
                var hours = d ? d.getUTCHours() : 0;
                var allowed = function (prop) { // Backwards compt with `Increment` option
                    return that.c[prop + 'Available'] ?
                        that.c[prop + 'Available'] :
                        that._range(0, 59, that.c[prop + 'Increment']);
                };

                this._optionsTime('hours', this.s.parts.hours12 ? 12 : 24, hours, this.c.hoursAvailable);
                this._optionsTime('minutes', 60, d ? d.getUTCMinutes() : 0, allowed('minutes'), this.s.minutesRange);
                this._optionsTime('seconds', 60, d ? d.getSeconds() : 0, allowed('seconds'), this.s.secondsRange);
            },

            /**
             * Show the widget and add events to the document required only while it
             * is displayed
             *
             * @private
             */
            _show: function () {
                var that = this;
                var namespace = this.s.namespace;

                this._position();

                // Need to reposition on scroll
                $(window).on('scroll.' + namespace + ' resize.' + namespace, function () {
                    that._hide();
                });

                $('div.DTE_Body_Content').on('scroll.' + namespace, function () {
                    that._hide();
                });

                $('div.dataTables_scrollBody').on('scroll.' + namespace, function () {
                    that._hide();
                });

                var offsetParent = this.dom.input[0].offsetParent;

                if (offsetParent !== document.body) {
                    $(offsetParent).on('scroll.' + namespace, function () {
                        that._hide();
                    });
                }

                // On tab focus will move to a different field (no keyboard navigation
                // in the date picker - this might need to be changed).
                $(document).on('keydown.' + namespace, function (e) {
                    if (
                        e.keyCode === 9 || // tab
                        e.keyCode === 27 || // esc
                        e.keyCode === 13    // return
                    ) {
                        that._hide();
                    }
                });

                // Hide if clicking outside of the widget - but in a different click
                // event from the one that was used to trigger the show (bubble and
                // inline)
                setTimeout(function () {
                    $('body').on('click.' + namespace, function (e) {
                        var parents = $(e.target).parents();

                        if (!parents.filter(that.dom.container).length && e.target !== that.dom.input[0]) {
                            that._hide();
                        }
                    });
                }, 10);
            },

            /**
             * Write the formatted string to the input element this control is attached
             * to
             *
             * @private
             */
            _writeOutput: function (focus) {
                var date = this.s.d;

                // Use moment or dayjs if possible - otherwise it must be ISO8601 (or the
                // constructor would have thrown an error)
                var out = dateLib ?
                    dateLib.utc(date, undefined$1, this.c.locale, this.c.strict).format(this.c.format) :
                    date.getUTCFullYear() + '-' +
                    this._pad(date.getUTCMonth() + 1) + '-' +
                    this._pad(date.getUTCDate());

                this.dom.input
                    .val(out)
                    .trigger('change', {write: date});

                if (focus) {
                    this.dom.input.focus();
                }
            }
        });

        /**
         * Use a specificmoment compatible date library
         */
        DateTime.use = function (lib) {
            dateLib = lib;
        };

        /**
         * For generating unique namespaces
         *
         * @type {Number}
         * @private
         */
        DateTime._instance = 0;

        /**
         * Defaults for the date time picker
         *
         * @type {Object}
         */
        DateTime.defaults = {
            attachTo: 'body',

            // Not documented - could be an internal property
            classPrefix: 'dt-datetime',

            // function or array of ints
            disableDays: null,

            // first day of the week (0: Sunday, 1: Monday, etc)
            firstDay: 1,

            format: 'YYYY-MM-DD',

            hoursAvailable: null,

            i18n: {
                previous: 'Previous',
                next: 'Next',
                months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
                weekdays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
                amPm: ['am', 'pm'],
                hours: 'Hour',
                minutes: 'Minute',
                seconds: 'Second',
                unknown: '-'
            },

            maxDate: null,

            minDate: null,

            minutesAvailable: null,

            minutesIncrement: 1, // deprecated

            strict: true,

            locale: 'en',

            onChange: function () {
            },

            secondsAvailable: null,

            secondsIncrement: 1, // deprecated

            // show the ISO week number at the head of the row
            showWeekNumber: false,

            // overruled by max / min date
            yearRange: 25
        };

        // Global export - if no conflicts
        if (!window.DateTime) {
            window.DateTime = DateTime;
        }

        // Make available via jQuery
        $.fn.dtDateTime = function (options) {
            return this.each(function () {
                new DateTime(this, options);
            });
        };

        // Attach to DataTables if present
        if ($.dataTable) {
            $.dataTable.DateTime = DateTime;
            $.DataTable.DateTime = DateTime;
        }

        return DateTime;

    }));

    var $;
    var DataTable;
    var moment = window.moment;

    /**
     * Sets the value of jQuery for use in the file
     * @param jq the instance of jQuery to be set
     */
    function setJQuery(jq) {
        $ = jq;
        DataTable = jq.fn.dataTable;
    }

    /**
     * The Criteria class is used within SearchBuilder to represent a search criteria
     */
    var Criteria = /** @class */ (function () {
        function Criteria(table, opts, topGroup, index, depth) {
            var _this = this;
            if (index === void 0) {
                index = 0;
            }
            if (depth === void 0) {
                depth = 1;
            }
            // Check that the required version of DataTables is included
            if (!DataTable || !DataTable.versionCheck || !DataTable.versionCheck('1.10.0')) {
                throw new Error('SearchPane requires DataTables 1.10 or newer');
            }
            this.classes = $.extend(true, {}, Criteria.classes);
            // Get options from user and any extra conditions/column types defined by plug-ins
            this.c = $.extend(true, {}, Criteria.defaults, $.fn.dataTable.ext.searchBuilder, opts);
            this.s = {
                condition: undefined,
                conditions: new Map(),
                data: undefined,
                dataIdx: -1,
                dataPoints: [],
                depth: depth,
                dt: table,
                filled: false,
                index: index,
                momentFormat: false,
                topGroup: topGroup,
                type: '',
                value: []
            };
            this.dom = {
                buttons: $('<div/>')
                    .addClass(this.classes.buttonContainer),
                condition: $('<select disabled/>')
                    .addClass(this.classes.condition)
                    .addClass(this.classes.dropDown)
                    .addClass(this.classes.italic),
                conditionTitle: $('<option value="" disabled selected hidden/>')
                    .text(this.s.dt.i18n('searchBuilder.condition', 'Condition')),
                container: $('<div/>')
                    .addClass(this.classes.container),
                data: $('<select/>')
                    .addClass(this.classes.data)
                    .addClass(this.classes.dropDown)
                    .addClass(this.classes.italic),
                dataTitle: $('<option value="" disabled selected hidden/>')
                    .text(this.s.dt.i18n('searchBuilder.data', 'Data')),
                defaultValue: $('<select disabled/>')
                    .addClass(this.classes.value)
                    .addClass(this.classes.dropDown),
                "delete": $('<button>&times</button>')
                    .addClass(this.classes["delete"])
                    .addClass(this.classes.button)
                    .attr('title', this.s.dt.i18n('searchBuilder.deleteTitle', 'Delete filtering rule')),
                left: $('<button>\<</button>')
                    .addClass(this.classes.left)
                    .addClass(this.classes.button)
                    .attr('title', this.s.dt.i18n('searchBuilder.leftTitle', 'Outdent criteria')),
                right: $('<button>\></button>')
                    .addClass(this.classes.right)
                    .addClass(this.classes.button)
                    .attr('title', this.s.dt.i18n('searchBuilder.rightTitle', 'Indent criteria')),
                value: [
                    $('<select disabled/>').addClass(this.classes.value).addClass(this.classes.dropDown).addClass(this.classes.italic)
                ],
                valueTitle: $('<option value="" disabled selected hidden/>').text(this.s.dt.i18n('searchBuilder.value', 'Value'))
            };
            // If the greyscale option is selected then add the class to add the grey colour to SearchBuilder
            if (this.c.greyscale) {
                $(this.dom.data).addClass(this.classes.greyscale);
                $(this.dom.condition).addClass(this.classes.greyscale);
                for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
                    var val = _a[_i];
                    $(val).addClass(this.classes.greyscale);
                }
            }
            // For responsive design, adjust the criterias properties on the following events
            this.s.dt.on('draw.dtsp', function () {
                _this._adjustCriteria();
            });
            this.s.dt.on('buttons-action', function () {
                _this._adjustCriteria();
            });
            $(window).on('resize.dtsp', DataTable.util.throttle(function () {
                _this._adjustCriteria();
            }));
            this._buildCriteria();
            return this;
        }

        /**
         * Adds the left button to the criteria
         */
        Criteria.prototype.updateArrows = function (hasSiblings, redraw) {
            if (hasSiblings === void 0) {
                hasSiblings = false;
            }
            if (redraw === void 0) {
                redraw = true;
            }
            // Empty the container and append all of the elements in the correct order
            $(this.dom.container)
                .empty()
                .append(this.dom.data)
                .append(this.dom.condition)
                .append(this.dom.value[0]);
            // Trigger the inserted events for the value elements as they are inserted
            $(this.dom.value[0]).trigger('dtsb-inserted');
            for (var i = 1; i < this.dom.value.length; i++) {
                $(this.dom.container).append(this.dom.value[i]);
                $(this.dom.value[i]).trigger('dtsb-inserted');
            }
            // If this is a top level criteria then don't let it move left
            if (this.s.depth > 1) {
                $(this.dom.buttons).append(this.dom.left);
            }
            // If the depthLimit of the query has been hit then don't add the right button
            if ((this.c.depthLimit === false || this.s.depth < this.c.depthLimit) && hasSiblings) {
                $(this.dom.buttons).append(this.dom.right);
            }
            $(this.dom.buttons).append(this.dom["delete"]);
            $(this.dom.container).append(this.dom.buttons);
            if (redraw) {
                // A different combination of arrows and selectors may lead to a need for responsive to be triggered
                this._adjustCriteria();
            }
        };
        /**
         * Destroys the criteria, removing listeners and container from the dom
         */
        Criteria.prototype.destroy = function () {
            // Turn off listeners
            $(this.dom.data).off('.dtsb');
            $(this.dom.condition).off('.dtsb');
            $(this.dom["delete"]).off('.dtsb');
            for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
                var val = _a[_i];
                $(val).off('.dtsb');
            }
            // Remove container from the dom
            $(this.dom.container).remove();
        };
        /**
         * Passes in the data for the row and compares it against this single criteria
         * @param rowData The data for the row to be compared
         * @returns boolean Whether the criteria has passed
         */
        Criteria.prototype.search = function (rowData) {
            var condition = this.s.conditions.get(this.s.condition);
            if (this.s.condition !== undefined && condition !== undefined) {
                return condition.search(rowData[this.s.dataIdx], this.s.value, this);
            }
        };
        /**
         * Gets the details required to rebuild the criteria
         */
        Criteria.prototype.getDetails = function () {
            return {
                condition: this.s.condition,
                data: this.s.data,
                value: this.s.value
            };
        };
        /**
         * Getter for the node for the container of the criteria
         * @returns JQuery<HTMLElement> the node for the container
         */
        Criteria.prototype.getNode = function () {
            return this.dom.container;
        };
        /**
         * Populates the criteria data, condition and value(s) as far as has been selected
         */
        Criteria.prototype.populate = function () {
            this._populateData();
            // If the column index has been found attempt to select a condition
            if (this.s.dataIdx !== -1) {
                this._populateCondition();
                // If the condittion has been found attempt to select the values
                if (this.s.condition !== undefined) {
                    this._populateValue();
                }
            }
        };
        /**
         * Rebuilds the criteria based upon the details passed in
         * @param loadedCriteria the details required to rebuild the criteria
         */
        Criteria.prototype.rebuild = function (loadedCriteria) {
            // Check to see if the previously selected data exists, if so select it
            var foundData = false;
            var dataIdx;
            this._populateData();
            // If a data selection has previously been made attempt to find and select it
            if (loadedCriteria.data !== undefined) {
                var italic_1 = this.classes.italic;
                var data_1 = this.dom.data;
                $(this.dom.data).children('option').each(function () {
                    if ($(this).text() === loadedCriteria.data) {
                        $(this).attr('selected', true);
                        $(data_1).removeClass(italic_1);
                        foundData = true;
                        dataIdx = $(this).val();
                    }
                });
            }
            // If the data has been found and selected then the condition can be populated and searched
            if (foundData) {
                this.s.data = loadedCriteria.data;
                this.s.dataIdx = dataIdx;
                $(this.dom.dataTitle).remove();
                this._populateCondition();
                $(this.dom.conditionTitle).remove();
                var condition_1;
                var conditions = this.s.conditions;
                // Check to see if the previously selected condition exists, if so select it
                $(this.dom.condition).children('option').each(function () {
                    if ((loadedCriteria.condition !== undefined &&
                        $(this).val() === loadedCriteria.condition &&
                        typeof loadedCriteria.condition === 'string')) {
                        $(this).attr('selected', true);
                        condition_1 = $(this).val();
                    }
                });
                this.s.condition = condition_1;
                // If the condition has been found and selected then the value can be populated and searched
                if (this.s.condition !== undefined) {
                    $(this.dom.conditionTitle).remove();
                    $(this.dom.condition).removeClass(this.classes.italic);
                    this._populateValue(loadedCriteria);
                } else {
                    $(this.dom.conditionTitle).prependTo(this.dom.condition).attr('selected', true);
                }
            }
        };
        /**
         * Sets the listeners for the criteria
         */
        Criteria.prototype.setListeners = function () {
            var _this = this;
            $(this.dom.data)
                .unbind('input')
                .on('input', function () {
                    $(_this.dom.dataTitle).attr('selected', false);
                    $(_this.dom.data).removeClass(_this.classes.italic);
                    _this.s.dataIdx = $(_this.dom.data).children('option:selected').val();
                    _this.s.data = $(_this.dom.data).children('option:selected').text();
                    // When the data is changed, the values in condition and value may also change so need to renew them
                    _this._clearCondition();
                    _this._clearValue();
                    _this._populateCondition();
                    // If this criteria was previously active in the search then remove it from the search and trigger a new search
                    if (_this.s.filled) {
                        _this.s.filled = false;
                        _this.s.dt.draw();
                        _this.setListeners();
                    }
                    _this.s.dt.state.save();
                });
            $(this.dom.condition)
                .unbind('input')
                .on('input', function () {
                    $(_this.dom.conditionTitle).attr('selected', false);
                    $(_this.dom.condition).removeClass(_this.classes.italic);
                    var condDisp = $(_this.dom.condition).children('option:selected').val();
                    // Find the condition that has been selected and store it internally
                    for (var _i = 0, _a = Array.from(_this.s.conditions.keys()); _i < _a.length; _i++) {
                        var cond = _a[_i];
                        if (cond === condDisp) {
                            _this.s.condition = condDisp;
                            break;
                        }
                    }
                    // When the condition is changed, the value selector may switch between a select element and an input element
                    _this._clearValue();
                    _this._populateValue();
                    for (var _b = 0, _c = _this.dom.value; _b < _c.length; _b++) {
                        var val = _c[_b];
                        // If this criteria was previously active in the search then remove it from the search and trigger a new search
                        if (_this.s.filled && $(_this.dom.container).has(val).length !== 0) {
                            _this.s.filled = false;
                            _this.s.dt.draw();
                            _this.setListeners();
                        }
                    }
                    _this.s.dt.draw();
                });
        };
        /**
         * Adjusts the criteria to make SearchBuilder responsive
         */
        Criteria.prototype._adjustCriteria = function () {
            // If this criteria is not present then don't bother adjusting it
            if ($(document).has(this.dom.container).length === 0) {
                return;
            }
            var valRight;
            var valWidth;
            var outmostval = this.dom.value[this.dom.value.length - 1];
            // Calculate the width and right value of the outmost value element
            if ($(this.dom.container).has(outmostval).length !== 0) {
                valWidth = $(outmostval).outerWidth(true);
                valRight = $(outmostval).offset().left + valWidth;
            } else {
                return;
            }
            var leftOffset = $(this.dom.left).offset();
            var rightOffset = $(this.dom.right).offset();
            var clearOffset = $(this.dom["delete"]).offset();
            var hasLeft = $(this.dom.container).has(this.dom.left).length !== 0;
            var hasRight = $(this.dom.container).has(this.dom.right).length !== 0;
            var buttonsLeft = hasLeft ?
                leftOffset.left :
                hasRight ?
                    rightOffset.left :
                    clearOffset.left;
            // Perform the responsive calculations and redraw where necessary
            if (buttonsLeft - valRight < 15 ||
                (hasLeft && leftOffset.top !== clearOffset.top) ||
                (hasRight && rightOffset.top !== clearOffset.top)) {
                $(this.dom.container).parent().addClass(this.classes.vertical);
                $(this.s.topGroup).trigger('dtsb-redrawContents');
            } else if (buttonsLeft -
                ($(this.dom.data).offset().left +
                    $(this.dom.data).outerWidth(true) +
                    $(this.dom.condition).outerWidth(true) +
                    valWidth) > 15) {
                $(this.dom.container).parent().removeClass(this.classes.vertical);
                $(this.s.topGroup).trigger('dtsb-redrawContents');
            }
        };
        /**
         * Builds the elements of the dom together
         */
        Criteria.prototype._buildCriteria = function () {
            // Append Titles for select elements
            $(this.dom.data).append(this.dom.dataTitle);
            $(this.dom.condition).append(this.dom.conditionTitle);
            // Add elements to container
            $(this.dom.container)
                .append(this.dom.data)
                .append(this.dom.condition);
            for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
                var val = _a[_i];
                $(val).append(this.dom.valueTitle);
                $(this.dom.container).append(val);
            }
            // Add buttons to container
            $(this.dom.container)
                .append(this.dom["delete"])
                .append(this.dom.right);
            this.setListeners();
        };
        /**
         * Clears the condition select element
         */
        Criteria.prototype._clearCondition = function () {
            $(this.dom.condition).empty();
            $(this.dom.conditionTitle).attr('selected', true).attr('disabled', true);
            $(this.dom.condition).append(this.dom.conditionTitle);
            this.s.conditions = new Map();
            this.s.condition = undefined;
        };
        /**
         * Clears the value elements
         */
        Criteria.prototype._clearValue = function () {
            if (this.s.condition !== undefined) {
                // Remove all of the value elements
                for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
                    var val = _a[_i];
                    $(val).remove();
                }
                // Call the init function to get the value elements for this condition
                var value = this.s.conditions.get(this.s.condition).init(this, Criteria.updateListener);
                this.dom.value = Array.isArray(value) ?
                    value :
                    [value];
                $(this.dom.value[0]).insertAfter(this.dom.condition).trigger('dtsb-inserted');
                // Insert all of the value elements
                for (var i = 1; i < this.dom.value.length; i++) {
                    $(this.dom.value[i]).insertAfter(this.dom.value[i - 1]).trigger('dtsb-inserted');
                }
            } else {
                // Remove all of the value elements
                for (var _b = 0, _c = this.dom.value; _b < _c.length; _b++) {
                    var val = _c[_b];
                    $(val).remove();
                }
                // Append the default valueTitle to the default select element
                $(this.dom.valueTitle)
                    .attr('selected', true)
                    .attr('disabled', false);
                $(this.dom.defaultValue)
                    .append(this.dom.valueTitle)
                    .insertAfter(this.dom.condition);
            }
            this.s.value = [];
        };
        /**
         * Populates the condition dropdown
         */
        Criteria.prototype._populateCondition = function () {
            var conditionOpts = [];
            // If there are no conditions stored then we need to get them from the appropriate type
            if (this.s.conditions.size === 0) {
                var column = $(this.dom.data).children('option:selected').val();
                this.s.type = this.s.dt.columns().type().toArray()[column];
                // If the column type is unknown, call a draw to try reading it again
                if (this.s.type === null) {
                    this.s.dt.draw();
                    this.setListeners();
                    this.s.type = this.s.dt.columns().type().toArray()[column];
                }
                // Enable the condition element
                $(this.dom.condition)
                    .attr('disabled', false)
                    .empty()
                    .append(this.dom.conditionTitle)
                    .addClass(this.classes.italic);
                $(this.dom.conditionTitle)
                    .attr('selected', true);
                // Select which conditions are going to be used based on the column type
                var conditionObj = this.c.conditions[this.s.type] !== undefined ?
                    this.c.conditions[this.s.type] :
                    this.s.type.indexOf('moment') !== -1 && $.fn.dataTable.moment !== undefined ?
                        this.c.conditions.moment :
                        this.c.conditions.string;
                // If it is a moment format then extract the date format
                if (this.s.type.indexOf('moment') !== -1) {
                    this.s.momentFormat = this.s.type.replace(/moment\-/g, '');
                }
                // Add all of the conditions to the select element
                for (var _i = 0, _a = Object.keys(conditionObj); _i < _a.length; _i++) {
                    var condition = _a[_i];
                    if (conditionObj[condition] !== null) {
                        this.s.conditions.set(condition, conditionObj[condition]);
                        conditionOpts.push($('<option>', {
                            text: conditionObj[condition].conditionName,
                            value: condition
                        })
                            .addClass(this.classes.option)
                            .addClass(this.classes.notItalic));
                    }
                }
            }
            // Otherwise we can just load them in
            else if (this.s.conditions.size > 0) {
                $(this.dom.condition).empty().attr('disabled', false).addClass(this.classes.italic);
                for (var _b = 0, _c = Array.from(this.s.conditions.keys()); _b < _c.length; _b++) {
                    var condition = _c[_b];
                    var condName = this.s.conditions.get(condition).conditionName;
                    var newOpt = $('<option>', {
                        text: condName,
                        value: condition
                    })
                        .addClass(this.classes.option)
                        .addClass(this.classes.notItalic);
                    if (this.s.condition !== undefined && this.s.condition === condName) {
                        $(newOpt).attr('selected', true);
                        $(this.dom.condition).removeClass(this.classes.italic);
                    }
                    conditionOpts.push(newOpt);
                }
            } else {
                $(this.dom.condition)
                    .attr('disabled', true)
                    .addClass(this.classes.italic);
                return;
            }
            // Sort the conditions so that they are displayed alphabetically
            conditionOpts.sort(function (a, b) {
                if ($(a).val() < $(b).val()) {
                    return -1;
                } else if ($(a).val() < $(b).val()) {
                    return 1;
                } else {
                    return 0;
                }
            });
            for (var _d = 0, conditionOpts_1 = conditionOpts; _d < conditionOpts_1.length; _d++) {
                var opt = conditionOpts_1[_d];
                $(this.dom.condition).append(opt);
            }
        };
        /**
         * Populates the data select element
         */
        Criteria.prototype._populateData = function () {
            var _this = this;
            $(this.dom.data).empty().append(this.dom.dataTitle);
            // If there are no datas stored then we need to get them from the table
            if (this.s.dataPoints.length === 0) {
                this.s.dt.columns().every(function (index) {
                    // Need to check that the column can be filtered on before adding it
                    if (_this.c.columns === true ||
                        (_this.s.dt.columns(_this.c.columns).indexes().toArray().indexOf(index) !== -1)) {
                        var found = false;
                        for (var _i = 0, _a = _this.s.dataPoints; _i < _a.length; _i++) {
                            var val = _a[_i];
                            if (val.index === index) {
                                found = true;
                                break;
                            }
                        }
                        if (!found) {
                            var opt = {text: _this.s.dt.settings()[0].aoColumns[index].sTitle, index: index};
                            _this.s.dataPoints.push(opt);
                            $(_this.dom.data).append($('<option>', {
                                text: opt.text,
                                value: opt.index
                            })
                                .addClass(_this.classes.option)
                                .addClass(_this.classes.notItalic));
                        }
                    }
                });
            }
            // Otherwise we can just load them in
            else {
                var _loop_1 = function (data) {
                    this_1.s.dt.columns().every(function (index) {
                        if (_this.s.dt.settings()[0].aoColumns[index].sTitle === data.text) {
                            data.index = index;
                        }
                    });
                    var newOpt = $('<option>', {
                        text: data.text,
                        value: data.index
                    })
                        .addClass(this_1.classes.option)
                        .addClass(this_1.classes.notItalic);
                    if (this_1.s.data === data.text) {
                        this_1.s.dataIdx = data.index;
                        $(newOpt).attr('selected', true);
                        $(this_1.dom.data).removeClass(this_1.classes.italic);
                    }
                    $(this_1.dom.data).append(newOpt);
                };
                var this_1 = this;
                for (var _i = 0, _a = this.s.dataPoints; _i < _a.length; _i++) {
                    var data = _a[_i];
                    _loop_1(data);
                }
            }
        };
        /**
         * Populates the Value select element
         * @param loadedCriteria optional, used to reload criteria from predefined filters
         */
        Criteria.prototype._populateValue = function (loadedCriteria) {
            var _this = this;
            var prevFilled = this.s.filled;
            this.s.filled = false;
            // Remove any previous value elements
            $(this.dom.defaultValue).remove();
            for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
                var val = _a[_i];
                $(val).remove();
            }
            var children = $(this.dom.container).children();
            if (children.length > 3) {
                for (var i = 2; i < children.length - 1; i++) {
                    $(children[i]).remove();
                }
            }
            // Find the column with the title matching the data for the criteria and take note of the index
            if (loadedCriteria !== undefined) {
                this.s.dt.columns().every(function (index) {
                    if (_this.s.dt.settings()[0].aoColumns[index].sTitle === loadedCriteria.data) {
                        _this.s.dataIdx = index;
                    }
                });
            }
            // Initialise the value elements based on the condition
            var value = this.s.conditions.get(this.s.condition).init(this, Criteria.updateListener, loadedCriteria !== undefined ? loadedCriteria.value : undefined);
            if (loadedCriteria !== undefined && loadedCriteria.value !== undefined) {
                this.s.value = loadedCriteria.value;
            }
            this.dom.value = Array.isArray(value) ?
                value :
                [value];
            // Insert value elements and trigger the inserted event
            $(this.dom.value[0])
                .insertAfter(this.dom.condition)
                .trigger('dtsb-inserted');
            for (var i = 1; i < this.dom.value.length; i++) {
                $(this.dom.value[i])
                    .insertAfter(this.dom.value[i - 1])
                    .trigger('dtsb-inserted');
            }
            // Check if the criteria can be used in a search
            this.s.filled = this.s.conditions.get(this.s.condition).isInputValid(this.dom.value, this);
            this.setListeners();
            // If it can and this is different to before then trigger a draw
            if (prevFilled !== this.s.filled) {
                this.s.dt.draw();
                this.setListeners();
            }
        };
        Criteria.version = '0.0.1';
        Criteria.classes = {
            button: 'dtsb-button',
            buttonContainer: 'dtsb-buttonContainer',
            condition: 'dtsb-condition',
            container: 'dtsb-criteria',
            data: 'dtsb-data',
            "delete": 'dtsb-delete',
            dropDown: 'dtsb-dropDown',
            greyscale: 'dtsb-greyscale',
            input: 'dtsb-input',
            italic: 'dtsb-italic',
            joiner: 'dtsp-joiner',
            left: 'dtsb-left',
            notItalic: 'dtsb-notItalic',
            option: 'dtsb-option',
            right: 'dtsb-right',
            value: 'dtsb-value',
            vertical: 'dtsb-vertical'
        };
        /**
         * Default initialisation function for select conditions
         */
        Criteria.initSelect = function (that, fn, preDefined) {
            if (preDefined === void 0) {
                preDefined = null;
            }
            var column = $(that.dom.data).children('option:selected').val();
            var indexArray = that.s.dt.rows().indexes().toArray();
            var settings = that.s.dt.settings()[0];
            // Declare select element to be used with all of the default classes and listeners.
            var el = $('<select/>')
                .addClass(Criteria.classes.value)
                .addClass(Criteria.classes.dropDown)
                .addClass(Criteria.classes.italic)
                .append(that.dom.valueTitle)
                .on('input', function () {
                    $(this).removeClass(Criteria.classes.italic);
                    fn(that, this);
                });
            var added = [];
            var options = [];
            // Add all of the options from the table to the select element.
            // Only add one option for each possible value
            for (var _i = 0, indexArray_1 = indexArray; _i < indexArray_1.length; _i++) {
                var index = indexArray_1[_i];
                var value = {
                    filter: settings.oApi._fnGetCellData(settings, index, column, that.c.orthogonal.search),
                    index: index,
                    text: settings.oApi._fnGetCellData(settings, index, column, 'display')
                };
                // Add text and value, stripping out any html if that is the column type
                var opt = $('<option>', {
                    text: that.s.type.includes('html') ? value.text.replace(/(<([^>]+)>)/ig, '') : value.text,
                    value: that.s.type.includes('html') ? value.filter.replace(/(<([^>]+)>)/ig, '') : value.filter
                })
                    .addClass(that.classes.option)
                    .addClass(that.classes.notItalic);
                var val = $(opt).val();
                // Check that this value has not already been added
                if (added.indexOf(val) === -1) {
                    // $(el).append(opt);
                    added.push(val);
                    options.push(opt);
                    // If this value was previously selected as indicated by preDefined, then select it again
                    if (preDefined !== null && opt.val() === preDefined[0]) {
                        opt.attr('selected', true);
                        that.dom.valueTitle.remove();
                        $(el).removeClass(Criteria.classes.italic);
                    }
                }
            }
            options.sort(function (a, b) {
                if (that.s.type === 'string' || that.s.type === 'num' || that.s.type === 'html' || that.s.type === 'html-num') {
                    if ($(a).val() < $(b).val()) {
                        return -1;
                    } else if ($(a).val() < $(b).val()) {
                        return 1;
                    } else {
                        return 0;
                    }
                } else if (that.s.type === 'num-fmt' || that.s.type === 'html-num-fmt') {
                    if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) {
                        return -1;
                    } else if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) {
                        return 1;
                    } else {
                        return 0;
                    }
                }
            });
            for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
                var opt = options_1[_a];
                $(el).append(opt);
            }
            return el;
        };
        /**
         * Default initialisation function for input conditions
         */
        Criteria.initInput = function (that, fn, preDefined) {
            if (preDefined === void 0) {
                preDefined = null;
            }
            // Declare the input element
            var el = $('<input/>')
                .addClass(Criteria.classes.value)
                .addClass(Criteria.classes.input)
                .on('input', function () {
                    fn(that, this);
                });
            // If there is a preDefined value then add it
            if (preDefined !== null) {
                $(el).val(preDefined[0]);
            }
            return el;
        };
        /**
         * Default initialisation function for conditions requiring 2 inputs
         */
        Criteria.init2Input = function (that, fn, preDefined) {
            if (preDefined === void 0) {
                preDefined = null;
            }
            // Declare all of the necessary jQuery elements
            var els = [
                $('<input/>')
                    .addClass(Criteria.classes.value)
                    .addClass(Criteria.classes.input)
                    .on('input', function () {
                        fn(that, this);
                    }),
                $('<span>')
                    .addClass(that.classes.joiner).text('and'),
                $('<input/>')
                    .addClass(Criteria.classes.value)
                    .addClass(Criteria.classes.input)
                    .on('input', function () {
                        fn(that, this);
                    })
            ];
            // If there is a preDefined value then add it
            if (preDefined !== null) {
                $(els[0]).val(preDefined[0]);
                $(els[2]).val(preDefined[1]);
            }
            return els;
        };
        /**
         * Default initialisation function for date conditions
         */
        Criteria.initDate = function (that, fn, preDefined) {
            if (preDefined === void 0) {
                preDefined = null;
            }
            // Declare date element using DataTables dateTime plugin
            var el = $('<input/>')
                .addClass(Criteria.classes.value)
                .addClass(Criteria.classes.input)
                .dtDateTime({
                    attachTo: 'input',
                    format: that.s.momentFormat ? that.s.momentFormat : undefined
                })
                .on('input change', function () {
                    fn(that, this);
                });
            // If there is a preDefined value then add it
            if (preDefined !== null) {
                $(el).val(preDefined[0]);
            }
            return el;
        };
        Criteria.init2Date = function (that, fn, preDefined) {
            if (preDefined === void 0) {
                preDefined = null;
            }
            // Declare all of the date elements that are required using DataTables dateTime plugin
            var els = [
                $('<input/>')
                    .addClass(Criteria.classes.value)
                    .addClass(Criteria.classes.input)
                    .dtDateTime({
                        attachTo: 'input',
                        format: that.s.momentFormat ? that.s.momentFormat : undefined
                    })
                    .on('input change', function () {
                        fn(that, this);
                    }),
                $('<span>')
                    .addClass(that.classes.joiner)
                    .text('and'),
                $('<input/>')
                    .addClass(Criteria.classes.value)
                    .addClass(Criteria.classes.input)
                    .dtDateTime({
                        attachTo: 'input',
                        format: that.s.momentFormat ? that.s.momentFormat : undefined
                    })
                    .on('input change', function () {
                        fn(that, this);
                    })
            ];
            // If there are and preDefined values then add them
            if (preDefined !== null && preDefined.length > 0) {
                $(els[0]).val(preDefined[0]);
                $(els[2]).val(preDefined[1]);
            }
            return els;
        };
        /**
         * Default function for select elements to validate condition
         */
        Criteria.isInputValidSelect = function (el) {
            var allFilled = true;
            // Check each element to make sure that the selections are valid
            for (var _i = 0, el_1 = el; _i < el_1.length; _i++) {
                var element = el_1[_i];
                if ($(element).children('option:selected').length === $(element).children('option').length - $(element).children('option.' + Criteria.classes.notItalic).length &&
                    $(element).children('option:selected').length === 1 &&
                    $(element).children('option:selected')[0] === $(element).children('option:hidden')[0]) {
                    allFilled = false;
                }
            }
            return allFilled;
        };
        /**
         * Default function for input and date elements to validate condition
         */
        Criteria.isInputValidInput = function (el) {
            var allFilled = true;
            // Check each element to make sure that the inputs are valid
            for (var _i = 0, el_2 = el; _i < el_2.length; _i++) {
                var element = el_2[_i];
                if ($(element).is('input') && $(element).val().length === 0) {
                    allFilled = false;
                }
            }
            return allFilled;
        };
        /**
         * Default function for getting select conditions
         */
        Criteria.inputValueSelect = function (el) {
            var values = [];
            // Go through the select elements and push each selected option to the return array
            for (var _i = 0, el_3 = el; _i < el_3.length; _i++) {
                var element = el_3[_i];
                if ($(element).is('select')) {
                    values.push($(element).children('option:selected').val());
                }
            }
            return values;
        };
        /**
         * Default function for getting input conditions
         */
        Criteria.inputValueInput = function (el) {
            var values = [];
            // Go through the input elements and push each value to the return array
            for (var _i = 0, el_4 = el; _i < el_4.length; _i++) {
                var element = el_4[_i];
                if ($(element).is('input')) {
                    values.push($(element).val());
                }
            }
            return values;
        };
        /**
         * Function that is run on each element as a call back when a search should be triggered
         */
        Criteria.updateListener = function (that, el) {
            // When the value is changed the criteria is now complete so can be included in searches
            // Get the condition from the map based on the key that has been selected for the condition
            var condition = that.s.conditions.get(that.s.condition);
            that.s.filled = condition.isInputValid(that.dom.value, that);
            that.s.value = condition.inputValue(that.dom.value, that);
            if (!Array.isArray(that.s.value)) {
                that.s.value = [that.s.value];
            }
            // Take note of the cursor position so that we can refocus there later
            var idx = null;
            var cursorPos = null;
            for (var i = 0; i < that.dom.value.length; i++) {
                if (el === that.dom.value[i][0]) {
                    idx = i;
                    if (el.selectionStart !== undefined) {
                        cursorPos = el.selectionStart;
                    }
                }
            }
            // Trigger a search
            that.s.dt.draw();
            // Refocus the element and set the correct cursor position
            if (idx !== null) {
                $(that.dom.value[idx]).removeClass(that.classes.italic);
                $(that.dom.value[idx]).focus();
                if (cursorPos !== null) {
                    $(that.dom.value[idx])[0].setSelectionRange(cursorPos, cursorPos);
                }
            }
        };
        Criteria.dateConditions = {
            '!=': {
                conditionName: 'Not',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    return value !== comparison[0];
                }
            },
            '!between': {
                conditionName: 'Not Between',
                init: Criteria.init2Date,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    if (comparison[0] < comparison[1]) {
                        return !(comparison[0] <= value && value <= comparison[1]);
                    } else {
                        return !(comparison[1] <= value && value <= comparison[0]);
                    }
                }
            },
            '!null': {
                conditionName: 'Not Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return !(value === null || value === undefined || value.length === 0);
                }
            },
            '<': {
                conditionName: 'Before',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    return value < comparison[0];
                }
            },
            '=': {
                conditionName: 'Equals',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    return value === comparison[0];
                }
            },
            '>': {
                conditionName: 'After',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    return value > comparison[0];
                }
            },
            'between': {
                conditionName: 'Between',
                init: Criteria.init2Date,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    value = value.replace(/(\/|\-|\,)/g, '-');
                    if (comparison[0] < comparison[1]) {
                        return comparison[0] <= value && value <= comparison[1];
                    } else {
                        return comparison[1] <= value && value <= comparison[0];
                    }
                }
            },
            'null': {
                conditionName: 'Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return (value === null || value === undefined || value.length === 0);
                }
            }
        };
        Criteria.momentDateConditions = {
            '!=': {
                conditionName: 'Not',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    return moment(value, that.s.momentFormat).valueOf() !== moment(comparison[0], that.s.momentFormat).valueOf();
                }
            },
            '!between': {
                conditionName: 'Not Between',
                init: Criteria.init2Date,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    var val = moment(value, that.s.momentFormat).valueOf();
                    var comp0 = moment(comparison[0], that.s.momentFormat).valueOf();
                    var comp1 = moment(comparison[1], that.s.momentFormat).valueOf();
                    if (comp0 < comp1) {
                        return !(+comp0 <= +val && +val <= +comp1);
                    } else {
                        return !(+comp1 <= +val && +val <= +comp0);
                    }
                }
            },
            '!null': {
                conditionName: 'Not Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return !(value === null || value === undefined || value.length === 0);
                }
            },
            '<': {
                conditionName: 'Before',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    return moment(value, that.s.momentFormat).valueOf() < moment(comparison[0], that.s.momentFormat).valueOf();
                }
            },
            '=': {
                conditionName: 'Equals',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    return moment(value, that.s.momentFormat).valueOf() === moment(comparison[0], that.s.momentFormat).valueOf();
                }
            },
            '>': {
                conditionName: 'After',
                init: Criteria.initDate,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    return moment(value, that.s.momentFormat).valueOf() > moment(comparison[0], that.s.momentFormat).valueOf();
                }
            },
            'between': {
                conditionName: 'Between',
                init: Criteria.init2Date,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison, that) {
                    var val = moment(value, that.s.momentFormat).valueOf();
                    var comp0 = moment(comparison[0], that.s.momentFormat).valueOf();
                    var comp1 = moment(comparison[1], that.s.momentFormat).valueOf();
                    if (comp0 < comp1) {
                        return comp0 <= val && val <= comp1;
                    } else {
                        return comp1 <= val && val <= comp0;
                    }
                }
            },
            'null': {
                conditionName: 'Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return (value === null || value === undefined || value.length === 0);
                }
            }
        };
        Criteria.numConditions = {
            '!=': {
                conditionName: 'Not',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidSelect,
                search: function (value, comparison) {
                    return +value !== +comparison[0];
                }
            },
            '!between': {
                conditionName: 'Not Between',
                init: Criteria.init2Input,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    if (+comparison[0] < +comparison[1]) {
                        return !(+comparison[0] <= +value && +value <= +comparison[1]);
                    } else {
                        return !(+comparison[1] <= +value && +value <= +comparison[0]);
                    }
                }
            },
            '!null': {
                conditionName: 'Not Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return !(value === null || value === undefined || value.length === 0);
                }
            },
            '<': {
                conditionName: 'Less Than',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return +value < +comparison[0];
                }
            },
            '<=': {
                conditionName: 'Less Than Equal To',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return +value <= +comparison[0];
                }
            },
            '=': {
                conditionName: 'Equals',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidSelect,
                search: function (value, comparison) {
                    return +value === +comparison[0];
                }
            },
            '>': {
                conditionName: 'Greater Than',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return +value > +comparison[0];
                }
            },
            '>=': {
                conditionName: 'Greater Than Equal To',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return +value >= +comparison[0];
                }
            },
            'between': {
                conditionName: 'Between',
                init: Criteria.init2Input,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    if (+comparison[0] < +comparison[1]) {
                        return +comparison[0] <= +value && +value <= +comparison[1];
                    } else {
                        return +comparison[1] <= +value && +value <= +comparison[0];
                    }
                }
            },
            'null': {
                conditionName: 'Empty',
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                isInputValid: function () {
                    return true;
                },
                search: function (value, comparison) {
                    return (value === null || value === undefined || value.length === 0);
                }
            }
        };
        Criteria.numFmtConditions = {
            '!=': {
                conditionName: 'Not',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidSelect,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp = comparison[0].replace(/[^0-9.]/g, '');
                    return +val !== +comp;
                }
            },
            '!between': {
                conditionName: 'Not Between',
                init: Criteria.init2Input,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    var comp1 = comparison[1].replace(/[^0-9.]/g, '');
                    if (comp0 < comp1) {
                        return !(+comp0 <= +val && +val <= +comp1);
                    } else {
                        return !(+comp1 <= +val && +val <= +comp0);
                    }
                }
            },
            '!null': {
                conditionName: 'Not Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return !(value === null || value === undefined || value.length === 0);
                }
            },
            '<': {
                conditionName: 'Less Than',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp = comparison[0].replace(/[^0-9.]/g, '');
                    return +val < +comp;
                }
            },
            '<=': {
                conditionName: 'Less Than Equal To',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    return +val <= +comp0;
                }
            },
            '=': {
                conditionName: 'Equals',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidSelect,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    return +val === +comp0;
                }
            },
            '>': {
                conditionName: 'Greater Than',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    return +val > +comp0;
                }
            },
            '>=': {
                conditionName: 'Greater Than Equal To',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    return +val >= +comp0;
                }
            },
            'between': {
                conditionName: 'Between',
                init: Criteria.init2Input,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    var val = value.replace(/[^0-9.]/g, '');
                    var comp0 = comparison[0].replace(/[^0-9.]/g, '');
                    var comp1 = comparison[1].replace(/[^0-9.]/g, '');
                    if (comp0 < comp1) {
                        return +comp0 <= +val && +val <= +comp1;
                    } else {
                        return +comp1 <= +val && +val <= +comp0;
                    }
                }
            },
            'null': {
                conditionName: 'Empty',
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                isInputValid: function () {
                    return true;
                },
                search: function (value, comparison) {
                    return (value === null || value === undefined || value.length === 0);
                }
            }
        };
        Criteria.stringConditions = {
            '!=': {
                conditionName: 'Not',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return value !== comparison[0];
                }
            },
            '!null': {
                conditionName: 'Not Empty',
                isInputValid: function () {
                    return true;
                },
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                search: function (value, comparison) {
                    return !(value === null || value === undefined || value.length === 0);
                }
            },
            '=': {
                conditionName: 'Equals',
                init: Criteria.initSelect,
                inputValue: Criteria.inputValueSelect,
                isInputValid: Criteria.isInputValidSelect,
                search: function (value, comparison) {
                    return value === comparison[0];
                }
            },
            'contains': {
                conditionName: 'Contains',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return value.toLowerCase().includes(comparison[0].toLowerCase());
                }
            },
            'ends': {
                conditionName: 'Ends With',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return value.toLowerCase().indexOf(comparison[0].toLowerCase()) === value.length - comparison[0].length;
                }
            },
            'null': {
                conditionName: 'Empty',
                init: function () {
                    return;
                },
                inputValue: function () {
                    return;
                },
                isInputValid: function () {
                    return true;
                },
                search: function (value, comparison) {
                    return (value === null || value === undefined || value.length === 0);
                }
            },
            'starts': {
                conditionName: 'Starts With',
                init: Criteria.initInput,
                inputValue: Criteria.inputValueInput,
                isInputValid: Criteria.isInputValidInput,
                search: function (value, comparison) {
                    return value.toLowerCase().indexOf(comparison[0].toLowerCase()) === 0;
                }
            }
        };
        Criteria.defaults = {
            columns: true,
            conditions: {
                'date': Criteria.dateConditions,
                'html': Criteria.stringConditions,
                'html-num': Criteria.numConditions,
                'html-num-fmt': Criteria.numFmtConditions,
                'moment': Criteria.momentDateConditions,
                'num': Criteria.numConditions,
                'num-fmt': Criteria.numFmtConditions,
                'string': Criteria.stringConditions
            },
            depthLimit: false,
            greyscale: false,
            orthogonal: {
                conditionName: 'Condition Name',
                search: 'filter'
            }
        };
        return Criteria;
    }());

    var $$1;
    var DataTable$1;

    /**
     * Sets the value of jQuery for use in the file
     * @param jq the instance of jQuery to be set
     */
    function setJQuery$1(jq) {
        $$1 = jq;
        DataTable$1 = jq.fn.dataTable;
    }

    /**
     * The Group class is used within SearchBuilder to represent a group of criteria
     */
    var Group = /** @class */ (function () {
        function Group(table, opts, topGroup, index, isChild, depth) {
            if (index === void 0) {
                index = 0;
            }
            if (isChild === void 0) {
                isChild = false;
            }
            if (depth === void 0) {
                depth = 1;
            }
            // Check that the required version of DataTables is included
            if (!DataTable$1 || !DataTable$1.versionCheck || !DataTable$1.versionCheck('1.10.0')) {
                throw new Error('SearchBuilder requires DataTables 1.10 or newer');
            }
            this.classes = $$1.extend(true, {}, Group.classes);
            // Get options from user
            this.c = $$1.extend(true, {}, Group.defaults, opts);
            this.s = {
                criteria: [],
                depth: depth,
                dt: table,
                index: index,
                isChild: isChild,
                logic: undefined,
                opts: opts,
                toDrop: undefined,
                topGroup: topGroup
            };
            this.dom = {
                add: $$1('<button/>')
                    .addClass(this.classes.add)
                    .addClass(this.classes.button),
                clear: $$1('<button>&times</button>')
                    .addClass(this.classes.button)
                    .addClass(this.classes.clearGroup),
                container: $$1('<div/>')
                    .addClass(this.classes.group),
                logic: $$1('<button/>')
                    .addClass(this.classes.logic)
                    .addClass(this.classes.button),
                logicContainer: $$1('<div/>')
                    .addClass(this.classes.logicContainer)
            };
            // A reference to the top level group is maintained throughout any subgroups and criteria that may be created
            if (this.s.topGroup === undefined) {
                this.s.topGroup = this.dom.container;
            }
            this._setup();
            return this;
        }

        /**
         * Destroys the groups buttons, clears the internal criteria and removes it from the dom
         */
        Group.prototype.destroy = function () {
            // Turn off listeners
            $$1(this.dom.add).off('.dtsb');
            $$1(this.dom.logic).off('.dtsb');
            // Trigger event for groups at a higher level to pick up on
            $$1(this.dom.container)
                .trigger('dtsb-destroy')
                .remove();
            this.s.criteria = [];
        };
        /**
         * Gets the details required to rebuild the group
         */
        Group.prototype.getDetails = function () {
            if (this.s.criteria.length === 0) {
                return {};
            }
            var details = {
                criteria: [],
                logic: this.s.logic
            };
            // NOTE here crit could be either a subgroup or a criteria
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                details.criteria.push(crit.criteria.getDetails());
            }
            return details;
        };
        /**
         * Getter for the node for the container of the group
         * @returns Node for the container of the group
         */
        Group.prototype.getNode = function () {
            return this.dom.container;
        };
        /**
         * Rebuilds the group based upon the details passed in
         * @param loadedDetails the details required to rebuild the group
         */
        Group.prototype.rebuild = function (loadedDetails) {
            // If no criteria are stored then just return
            if (loadedDetails.criteria === undefined || loadedDetails.criteria === null || loadedDetails.criteria.length === 0) {
                return;
            }
            this.s.logic = loadedDetails.logic;
            $$1(this.dom.logic).text(this.s.logic === 'OR' ? this.s.dt.i18n('searchBuilder.logicOr', 'Or') : this.s.dt.i18n('searchBuilder.logicAnd', 'And'));
            // Add all of the criteria, be it a sub group or a criteria
            for (var _i = 0, _a = loadedDetails.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                if (crit.logic !== undefined) {
                    this._addPrevGroup(crit);
                } else if (crit.logic === undefined) {
                    this._addPrevCriteria(crit);
                }
            }
            // For all of the criteria children, update the arrows incase they require changing and set the listeners
            for (var _b = 0, _c = this.s.criteria; _b < _c.length; _b++) {
                var crit = _c[_b];
                if (crit.logic === undefined) {
                    crit.criteria.updateArrows(this.s.criteria.length > 1, false);
                    this._setCriteriaListeners(crit.criteria);
                }
            }
        };
        /**
         * Redraws the Contents of the searchBuilder Groups and Criteria
         */
        Group.prototype.redrawContents = function () {
            // Clear the container out and add the basic elements
            $$1(this.dom.container)
                .empty()
                .append(this.dom.logicContainer)
                .append(this.dom.add);
            // Sort the criteria by index so that they appear in the correct order
            this.s.criteria.sort(function (a, b) {
                if (a.criteria.s.index < b.criteria.s.index) {
                    return -1;
                } else if (a.criteria.s.index > b.criteria.s.index) {
                    return 1;
                }
                return 0;
            });
            this.setListeners();
            for (var i = 0; i < this.s.criteria.length; i++) {
                if (this.s.criteria[i].logic === undefined) {
                    // Reset the index to the new value
                    this.s.criteria[i].index = i;
                    this.s.criteria[i].criteria.s.index = i;
                    // Add to the group
                    $$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add);
                    // Set listeners for various points
                    this._setCriteriaListeners(this.s.criteria[i].criteria);
                    this.s.criteria[i].criteria.rebuild(this.s.criteria[i].criteria.getDetails());
                } else if (this.s.criteria[i].criteria.s.criteria.length > 0) {
                    // Reset the index to the new value
                    this.s.criteria[i].index = i;
                    this.s.criteria[i].criteria.s.index = i;
                    // Add the sub group to the group
                    $$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add);
                    // Redraw the contents of the group
                    this.s.criteria[i].criteria.redrawContents();
                    this._setGroupListeners(this.s.criteria[i].criteria);
                } else {
                    // The group is empty so remove it
                    this.s.criteria.splice(i, 1);
                    i--;
                }
            }
            this.setupLogic();
        };
        /**
         * Search method, checking the row data against the criteria in the group
         * @param rowData The row data to be compared
         * @returns boolean The result of the search
         */
        Group.prototype.search = function (rowData) {
            if (this.s.logic === 'AND') {
                return this._andSearch(rowData);
            } else if (this.s.logic === 'OR') {
                return this._orSearch(rowData);
            }
            return true;
        };
        /**
         * Locates the groups logic button to the correct location on the page
         */
        Group.prototype.setupLogic = function () {
            // Remove logic button
            $$1(this.dom.logicContainer).remove();
            $$1(this.dom.clear).remove();
            // If there are no criteria in the group then keep the logic removed and return
            if (this.s.criteria.length < 1) {
                if (!this.s.isChild) {
                    $$1(this.dom.container).trigger('dtsb-destroy');
                    // Set criteria left margin
                    $$1(this.dom.container).css('margin-left', 0);
                }
                return;
            }
            // Set width, take 2 for the border
            var height = $$1(this.dom.container).height() - 2;
            $$1(this.dom.clear).height('0px');
            $$1(this.dom.logicContainer).append(this.dom.clear).width(height);
            // Prepend logic button
            $$1(this.dom.container).prepend(this.dom.logicContainer);
            this._setLogicListener();
            // Set criteria left margin
            $$1(this.dom.container).css('margin-left', $$1(this.dom.logicContainer).outerHeight(true));
            var logicOffset = $$1(this.dom.logicContainer).offset();
            // Set horizontal alignment
            var currentLeft = logicOffset.left;
            var groupLeft = $$1(this.dom.container).offset().left;
            var shuffleLeft = currentLeft - groupLeft;
            var newPos = currentLeft - shuffleLeft - $$1(this.dom.logicContainer).outerHeight(true);
            $$1(this.dom.logicContainer).offset({left: newPos});
            // Set vertical alignment
            var firstCrit = $$1(this.dom.logicContainer).next();
            var currentTop = logicOffset.top;
            var firstTop = $$1(firstCrit).offset().top;
            var shuffleTop = currentTop - firstTop;
            var newTop = currentTop - shuffleTop;
            $$1(this.dom.logicContainer).offset({top: newTop});
            $$1(this.dom.clear).outerHeight($$1(this.dom.logicContainer).height());
            this._setClearListener();
        };
        /**
         * Sets listeners on the groups elements
         */
        Group.prototype.setListeners = function () {
            var _this = this;
            $$1(this.dom.add).unbind('click');
            $$1(this.dom.add).on('click', function () {
                // If this is the parent group then the logic button has not been added yet
                if (!_this.s.isChild) {
                    $$1(_this.dom.container).prepend(_this.dom.logicContainer);
                }
                _this.addCriteria();
                $$1(_this.dom.container).trigger('dtsb-add');
                _this.s.dt.state.save();
                return false;
            });
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                crit.criteria.setListeners();
            }
            this._setClearListener();
            this._setLogicListener();
        };
        /**
         * Adds a criteria to the group
         * @param crit Instance of Criteria to be added to the group
         */
        Group.prototype.addCriteria = function (crit, redraw) {
            if (crit === void 0) {
                crit = null;
            }
            if (redraw === void 0) {
                redraw = true;
            }
            var index = crit === null ? this.s.criteria.length : crit.s.index;
            var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, index, this.s.depth);
            // If a Criteria has been passed in then set the values to continue that
            if (crit !== null) {
                criteria.c = crit.c;
                criteria.s = crit.s;
                criteria.s.depth = this.s.depth;
                criteria.classes = crit.classes;
            }
            criteria.populate();
            var inserted = false;
            for (var i = 0; i < this.s.criteria.length; i++) {
                if (i === 0 && this.s.criteria[i].criteria.s.index > criteria.s.index) {
                    // Add the node for the criteria at the start of the group
                    $$1(criteria.getNode()).insertBefore(this.s.criteria[i].criteria.dom.container);
                    inserted = true;
                } else if (i < this.s.criteria.length - 1 &&
                    this.s.criteria[i].criteria.s.index < criteria.s.index &&
                    this.s.criteria[i + 1].criteria.s.index > criteria.s.index) {
                    // Add the node for the criteria in the correct location
                    $$1(criteria.getNode()).insertAfter(this.s.criteria[i].criteria.dom.container);
                    inserted = true;
                }
            }
            if (!inserted) {
                $$1(criteria.getNode()).insertBefore(this.dom.add);
            }
            // Add the details for this criteria to the array
            this.s.criteria.push({
                criteria: criteria,
                index: index
            });
            this.s.criteria = this.s.criteria.sort(function (a, b) {
                return a.criteria.s.index - b.criteria.s.index;
            });
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var opt = _a[_i];
                if (opt.logic === undefined) {
                    opt.criteria.updateArrows(this.s.criteria.length > 1, redraw);
                }
            }
            this._setCriteriaListeners(criteria);
            criteria.setListeners();
            this.setupLogic();
        };
        /**
         * Checks the group to see if it has any filled criteria
         */
        Group.prototype.checkFilled = function () {
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                if ((crit.logic === undefined && crit.criteria.s.filled) ||
                    (crit.logic !== undefined && crit.criteria.checkFilled())) {
                    return true;
                }
            }
            return false;
        };
        /**
         * Gets the count for the number of criteria in this group and any sub groups
         */
        Group.prototype.count = function () {
            var count = 0;
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                if (crit.logic !== undefined) {
                    count += crit.criteria.count();
                } else {
                    count++;
                }
            }
            return count;
        };
        /**
         * Rebuilds a sub group that previously existed
         * @param loadedGroup The details of a group within this group
         */
        Group.prototype._addPrevGroup = function (loadedGroup) {
            var idx = this.s.criteria.length;
            var group = new Group(this.s.dt, this.c, this.s.topGroup, idx, true, this.s.depth + 1);
            // Add the new group to the criteria array
            this.s.criteria.push({
                criteria: group,
                index: idx,
                logic: group.s.logic
            });
            // Rebuild it with the previous conditions for that group
            group.rebuild(loadedGroup);
            this.s.criteria[idx].criteria = group;
            $$1(this.s.topGroup).trigger('dtsb-redrawContents');
            this._setGroupListeners(group);
        };
        /**
         * Rebuilds a criteria of this group that previously existed
         * @param loadedCriteria The details of a criteria within the group
         */
        Group.prototype._addPrevCriteria = function (loadedCriteria) {
            var idx = this.s.criteria.length;
            var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, idx, this.s.depth);
            criteria.populate();
            // Add the new criteria to the criteria array
            this.s.criteria.push({
                criteria: criteria,
                index: idx
            });
            // Rebuild it with the previous conditions for that criteria
            criteria.rebuild(loadedCriteria);
            this.s.criteria[idx].criteria = criteria;
            $$1(this.s.topGroup).trigger('dtsb-redrawContents');
        };
        /**
         * Checks And the criteria using AND logic
         * @param rowData The row data to be checked against the search criteria
         * @returns boolean The result of the AND search
         */
        Group.prototype._andSearch = function (rowData) {
            // If there are no criteria then return true for this group
            if (this.s.criteria.length === 0) {
                return true;
            }
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                // If the criteria is not complete then skip it
                if (crit.logic === undefined && !crit.criteria.s.filled) {
                    continue;
                }
                // Otherwise if a single one fails return false
                else if (!crit.criteria.search(rowData)) {
                    return false;
                }
            }
            // If we get to here then everything has passed, so return true for the group
            return true;
        };
        /**
         * Checks And the criteria using OR logic
         * @param rowData The row data to be checked against the search criteria
         * @returns boolean The result of the OR search
         */
        Group.prototype._orSearch = function (rowData) {
            // If there are no criteria in the group then return true
            if (this.s.criteria.length === 0) {
                return true;
            }
            // This will check to make sure that at least one criteria in the group is complete
            var filledfound = false;
            for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                if (crit.criteria.s.filled) {
                    // A completed criteria has been found so set the flag
                    filledfound = true;
                    // If the search passes then return true
                    if (crit.criteria.search(rowData)) {
                        return true;
                    }
                } else if (crit.logic !== undefined && crit.criteria.checkFilled()) {
                    filledfound = true;
                    if (crit.criteria.search(rowData)) {
                        return true;
                    }
                }
            }
            // If we get here we need to return the inverse of filledfound,
            //  as if any have been found and we are here then none have passed
            return !filledfound;
        };
        /**
         * Removes a criteria from the group
         * @param criteria The criteria instance to be removed
         */
        Group.prototype._removeCriteria = function (criteria, group) {
            if (group === void 0) {
                group = false;
            }
            // If removing a criteria and there is only then then just destroy the group
            if (this.s.criteria.length <= 1 && this.s.isChild) {
                this.destroy();
            } else {
                // Otherwise splice the given criteria out and redo the indexes
                var last = void 0;
                for (var i = 0; i < this.s.criteria.length; i++) {
                    if (this.s.criteria[i].index === criteria.s.index && (!group || this.s.criteria[i].criteria instanceof Group)) {
                        last = i;
                    }
                }
                // We want to remove the last element with the desired index, as its replacement will be inserted before it
                if (last !== undefined) {
                    this.s.criteria.splice(last, 1);
                }
                for (var i = 0; i < this.s.criteria.length; i++) {
                    this.s.criteria[i].index = i;
                    this.s.criteria[i].criteria.s.index = i;
                }
            }
        };
        /**
         * Sets the listeners in group for a criteria
         * @param criteria The criteria for the listeners to be set on
         */
        Group.prototype._setCriteriaListeners = function (criteria) {
            var _this = this;
            $$1(criteria.dom["delete"])
                .unbind('click')
                .on('click', function () {
                    _this._removeCriteria(criteria);
                    $$1(criteria.dom.container).remove();
                    _this.setupLogic();
                    for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) {
                        var crit = _a[_i];
                        if (crit.logic === undefined) {
                            crit.criteria.updateArrows(_this.s.criteria.length > 1);
                        }
                    }
                    criteria.destroy();
                    _this.s.dt.draw();
                    $$1(_this.s.topGroup).trigger('dtsb-updateTitle');
                    return false;
                });
            $$1(criteria.dom.right)
                .unbind('click')
                .on('click', function () {
                    var idx = criteria.s.index;
                    var group = new Group(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index, true, _this.s.depth + 1);
                    // Add the criteria that is to be moved to the new group
                    group.addCriteria(criteria);
                    // Update the details in the current groups criteria array
                    _this.s.criteria[idx].criteria = group;
                    _this.s.criteria[idx].logic = 'AND';
                    $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
                    _this._setGroupListeners(group);
                    return false;
                });
            $$1(criteria.dom.left)
                .unbind('click')
                .on('click', function () {
                    _this.s.toDrop = new Criteria(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index);
                    _this.s.toDrop.s = criteria.s;
                    _this.s.toDrop.c = criteria.c;
                    _this.s.toDrop.classes = criteria.classes;
                    _this.s.toDrop.populate();
                    // The dropCriteria event mutates the reference to the index so need to store it
                    var index = _this.s.toDrop.s.index;
                    $$1(_this.dom.container).trigger('dtsb-dropCriteria');
                    criteria.s.index = index;
                    _this._removeCriteria(criteria);
                    // By tracking the top level group we can directly trigger a redraw on it,
                    //  bubbling is also possible, but that is slow with deep levelled groups
                    $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
                    _this.s.dt.draw();
                    return false;
                });
        };
        /**
         * Set's the listeners for the group clear button
         */
        Group.prototype._setClearListener = function () {
            var _this = this;
            $$1(this.dom.clear)
                .unbind('click')
                .on('click', function () {
                    if (!_this.s.isChild) {
                        $$1(_this.dom.container).trigger('dtsb-clearContents');
                        return false;
                    }
                    _this.destroy();
                    $$1(_this.s.topGroup).trigger('dtsb-updateTitle');
                    $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
                    return false;
                });
        };
        /**
         * Sets listeners for sub groups of this group
         * @param group The sub group that the listeners are to be set on
         */
        Group.prototype._setGroupListeners = function (group) {
            var _this = this;
            // Set listeners for the new group
            $$1(group.dom.add)
                .unbind('click')
                .on('click', function () {
                    _this.setupLogic();
                    $$1(_this.dom.container).trigger('dtsb-add');
                    return false;
                });
            $$1(group.dom.container)
                .unbind('dtsb-add')
                .on('dtsb-add', function () {
                    _this.setupLogic();
                    $$1(_this.dom.container).trigger('dtsb-add');
                    return false;
                });
            $$1(group.dom.container)
                .unbind('dtsb-destroy')
                .on('dtsb-destroy', function () {
                    _this._removeCriteria(group, true);
                    $$1(group.dom.container).remove();
                    _this.setupLogic();
                    return false;
                });
            $$1(group.dom.container)
                .unbind('dtsb-dropCriteria')
                .on('dtsb-dropCriteria', function () {
                    var toDrop = group.s.toDrop;
                    toDrop.s.index = group.s.index;
                    toDrop.updateArrows(_this.s.criteria.length > 1, false);
                    _this.addCriteria(toDrop, false);
                    return false;
                });
            group.setListeners();
        };
        /**
         * Sets up the Group instance, setting listeners and appending elements
         */
        Group.prototype._setup = function () {
            this.setListeners();
            $$1(this.dom.add).text(this.s.dt.i18n('searchBuilder.add', 'Add Condition'));
            $$1(this.dom.logic).text(this.c.logic === 'OR' ? this.s.dt.i18n('searchBuilder.logicOr', 'Or') : this.s.dt.i18n('searchBuilder.logicAnd', 'And'));
            this.s.logic = this.c.logic === 'OR' ? 'OR' : 'AND';
            if (this.c.greyscale) {
                $$1(this.dom.logic).addClass(this.classes.greyscale);
            }
            $$1(this.dom.logicContainer).append(this.dom.logic).append(this.dom.clear);
            // Only append the logic button immediately if this is a sub group,
            //  otherwise it will be prepended later when adding a criteria
            if (this.s.isChild) {
                $$1(this.dom.container).append(this.dom.logicContainer);
            }
            $$1(this.dom.container).append(this.dom.add);
        };
        /**
         * Sets the listener for the logic button
         */
        Group.prototype._setLogicListener = function () {
            var _this = this;
            $$1(this.dom.logic)
                .unbind('click')
                .on('click', function () {
                    _this._toggleLogic();
                    _this.s.dt.draw();
                    for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) {
                        var crit = _a[_i];
                        crit.criteria.setListeners();
                    }
                });
        };
        /**
         * Toggles the logic for the group
         */
        Group.prototype._toggleLogic = function () {
            if (this.s.logic === 'OR') {
                this.s.logic = 'AND';
                $$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicAnd', 'And'));
            } else if (this.s.logic === 'AND') {
                this.s.logic = 'OR';
                $$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicOr', 'Or'));
            }
        };
        Group.version = '0.0.1';
        Group.classes = {
            add: 'dtsb-add',
            button: 'dtsb-button',
            clearGroup: 'dtsb-clearGroup',
            greyscale: 'dtsb-greyscale',
            group: 'dtsb-group',
            inputButton: 'dtsb-iptbtn',
            logic: 'dtsb-logic',
            logicContainer: 'dtsb-logicContainer'
        };
        Group.defaults = {
            depthLimit: false,
            greyscale: false,
            logic: 'AND'
        };
        return Group;
    }());

    var $$2;
    var DataTable$2;

    /**
     * Sets the value of jQuery for use in the file
     * @param jq the instance of jQuery to be set
     */
    function setJQuery$2(jq) {
        $$2 = jq;
        DataTable$2 = jq.fn.DataTable;
    }

    /**
     * SearchBuilder class for DataTables.
     * Allows for complex search queries to be constructed and implemented on a DataTable
     */
    var SearchBuilder = /** @class */ (function () {
        function SearchBuilder(builderSettings, opts) {
            var _this = this;
            // Check that the required version of DataTables is included
            if (!DataTable$2 || !DataTable$2.versionCheck || !DataTable$2.versionCheck('1.10.0')) {
                throw new Error('SearchBuilder requires DataTables 1.10 or newer');
            }
            var table = new DataTable$2.Api(builderSettings);
            this.classes = $$2.extend(true, {}, SearchBuilder.classes);
            // Get options from user
            this.c = $$2.extend(true, {}, SearchBuilder.defaults, opts);
            this.dom = {
                clearAll: $$2('<button type="button">' + table.i18n('searchBuilder.clearAll', 'Clear All') + '</button>')
                    .addClass(this.classes.clearAll)
                    .addClass(this.classes.button),
                container: $$2('<div/>')
                    .addClass(this.classes.container),
                title: $$2('<div/>')
                    .addClass(this.classes.title),
                titleRow: $$2('<div/>')
                    .addClass(this.classes.titleRow),
                topGroup: undefined
            };
            this.s = {
                dt: table,
                opts: opts,
                search: undefined,
                topGroup: undefined
            };
            // If searchbuilder is already defined for this table then return
            if (table.settings()[0]._searchBuilder !== undefined) {
                return;
            }
            table.settings()[0]._searchBuilder = this;
            // Run the remaining setup when the table is initialised
            if (this.s.dt.settings()[0]._bInitComplete) {
                this._setUp();
            } else {
                table.one('init.dt', function () {
                    _this._setUp();
                });
            }
            return this;
        }

        /**
         * Gets the details required to rebuild the SearchBuilder as it currently is
         */
        SearchBuilder.prototype.getDetails = function () {
            return this.s.topGroup.getDetails();
        };
        /**
         * Getter for the node of the container for the searchBuilder
         * @returns JQuery<HTMLElement> the node of the container
         */
        SearchBuilder.prototype.getNode = function () {
            return this.dom.container;
        };
        /**
         * Rebuilds the SearchBuilder to a state that is provided
         * @param details The details required to perform a rebuild
         */
        SearchBuilder.prototype.rebuild = function (details) {
            $$2(this.dom.clearAll).click();
            // If there are no details to rebuild then return
            if (details === undefined || details === null) {
                return this;
            }
            this.s.topGroup.rebuild(details);
            this.s.dt.draw();
            this.s.topGroup.setListeners();
            return this;
        };
        /**
         * Applies the defaults to preDefined criteria
         * @param preDef the array of criteria to be processed.
         */
        SearchBuilder.prototype._applyPreDefDefaults = function (preDef) {
            var _this = this;
            if (preDef.criteria !== undefined && preDef.logic === undefined) {
                preDef.logic = 'AND';
            }
            var _loop_1 = function (crit) {
                // Apply the defaults to any further criteria
                if (crit.criteria !== undefined) {
                    crit = this_1._applyPreDefDefaults(crit);
                } else {
                    this_1.s.dt.columns().every(function (index) {
                        if (_this.s.dt.settings()[0].aoColumns[index].sTitle === crit.data) {
                            crit.dataIdx = index;
                        }
                    });
                }
            };
            var this_1 = this;
            for (var _i = 0, _a = preDef.criteria; _i < _a.length; _i++) {
                var crit = _a[_i];
                _loop_1(crit);
            }
            return preDef;
        };
        /**
         * Set's up the SearchBuilder
         */
        SearchBuilder.prototype._setUp = function (loadState) {
            var _this = this;
            if (loadState === void 0) {
                loadState = true;
            }
            this.s.topGroup = new Group(this.s.dt, this.c, undefined);
            this._setClearListener();
            this.s.dt.on('stateSaveParams', function (e, settings, data) {
                data.searchBuilder = _this.getDetails();
                data.page = _this.s.dt.page();
            });
            this._build();
            if (loadState) {
                var loadedState = this.s.dt.state.loaded();
                // If the loaded State is not null rebuild based on it for statesave
                if (loadedState !== null && loadedState.searchBuilder !== undefined) {
                    this.s.topGroup.rebuild(loadedState.searchBuilder);
                    $$2(this.s.topGroup.dom.container).trigger('dtsb-redrawContents');
                    this.s.dt.page(loadedState.page).draw('page');
                    this.s.topGroup.setListeners();
                }
                // Otherwise load any predefined options
                else if (this.c.preDefined !== false) {
                    this.c.preDefined = this._applyPreDefDefaults(this.c.preDefined);
                    this.rebuild(this.c.preDefined);
                }
            }
            this._setEmptyListener();
            this.s.dt.state.save();
        };
        /**
         * Updates the title of the SearchBuilder
         * @param count the number of filters in the SearchBuilder
         */
        SearchBuilder.prototype._updateTitle = function (count) {
            $$2(this.dom.title).text(this.s.dt.i18n('searchBuilder.title', {
                0: 'Custom Search Builder',
                _: 'Custom Search Builder (%d)'
            }, count));
        };
        /**
         * Builds all of the dom elements together
         */
        SearchBuilder.prototype._build = function () {
            var _this = this;
            // Empty and setup the container
            $$2(this.dom.clearAll).remove();
            $$2(this.dom.container).empty();
            var count = this.s.topGroup.count();
            this._updateTitle(count);
            $$2(this.dom.titleRow).append(this.dom.title);
            $$2(this.dom.container).append(this.dom.titleRow);
            this.dom.topGroup = this.s.topGroup.getNode();
            $$2(this.dom.container).append(this.dom.topGroup);
            this._setRedrawListener();
            var tableNode = this.s.dt.table(0).node();
            if ($$2.fn.dataTable.ext.search.indexOf(this.s.search) === -1) {
                // Custom search function for SearchBuilder
                this.s.search = function (settings, searchData, dataIndex, origData) {
                    if (settings.nTable !== tableNode) {
                        return true;
                    }
                    return _this.s.topGroup.search(searchData);
                };
                // Add SearchBuilder search function to the dataTables search array
                $$2.fn.dataTable.ext.search.push(this.s.search);
            }
            // Register an Api method for getting the column type
            $$2.fn.DataTable.Api.registerPlural('columns().type()', 'column().type()', function (selector, opts) {
                return this.iterator('column', function (settings, column) {
                    return settings.aoColumns[column].sType;
                }, 1);
            });
            this.s.dt.on('destroy.dt', function () {
                $$2(_this.dom.container).remove();
                $$2(_this.dom.clearAll).remove();
                var searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search);
                while (searchIdx !== -1) {
                    $$2.fn.dataTable.ext.search.splice(searchIdx, 1);
                    searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search);
                }
            });
        };
        /**
         * Checks if the clearAll button should be added or not
         */
        SearchBuilder.prototype._checkClear = function () {
            if (this.s.topGroup.s.criteria.length > 0) {
                $$2(this.dom.clearAll).insertAfter(this.dom.title);
                this._setClearListener();
            } else {
                $$2(this.dom.clearAll).remove();
            }
        };
        /**
         * Set the listener for the clear button
         */
        SearchBuilder.prototype._setClearListener = function () {
            var _this = this;
            $$2(this.dom.clearAll).unbind('click');
            $$2(this.dom.clearAll).on('click', function () {
                _this.s.topGroup = new Group(_this.s.dt, _this.s.opts, undefined);
                _this._build();
                _this.s.dt.draw();
                _this.s.topGroup.setListeners();
                $$2(_this.dom.clearAll).remove();
                _this._setEmptyListener();
                // Update the count in the title/button
                if (_this.c.filterChanged !== undefined && typeof _this.c.filterChanged === 'function') {
                    _this.c.filterChanged(0);
                }
                return false;
            });
        };
        /**
         * Set the listener for the Redraw event
         */
        SearchBuilder.prototype._setRedrawListener = function () {
            var _this = this;
            $$2(this.s.topGroup.dom.container).unbind('dtsb-redrawContents');
            $$2(this.s.topGroup.dom.container).on('dtsb-redrawContents', function () {
                _this._checkClear();
                _this.s.topGroup.redrawContents();
                _this.s.topGroup.setupLogic();
                _this._setEmptyListener();
                var count = _this.s.topGroup.count();
                _this._updateTitle(count);
                // Update the count in the title/button
                if (_this.c.filterChanged !== undefined && typeof _this.c.filterChanged === 'function') {
                    _this.c.filterChanged(count);
                }
                _this.s.dt.state.save();
            });
            $$2(this.s.topGroup.dom.container).unbind('dtsb-clearContents');
            $$2(this.s.topGroup.dom.container).on('dtsb-clearContents', function () {
                _this._setUp(false);
                // Update the count in the title/button
                if (_this.c.filterChanged !== undefined && typeof _this.c.filterChanged === 'function') {
                    _this.c.filterChanged(0);
                }
                _this.s.dt.draw();
            });
            $$2(this.s.topGroup.dom.container).on('dtsb-updateTitle', function () {
                var count = _this.s.topGroup.count();
                _this._updateTitle(count);
                // Update the count in the title/button
                if (_this.c.filterChanged !== undefined && typeof _this.c.filterChanged === 'function') {
                    _this.c.filterChanged(count);
                }
            });
        };
        /**
         * Sets listeners to check whether clearAll should be added or removed
         */
        SearchBuilder.prototype._setEmptyListener = function () {
            var _this = this;
            $$2(this.s.topGroup.dom.add).on('click', function () {
                _this._checkClear();
            });
            $$2(this.s.topGroup.dom.container).on('dtsb-destroy', function () {
                $$2(_this.dom.clearAll).remove();
            });
        };
        SearchBuilder.version = '0.0.1';
        SearchBuilder.classes = {
            button: 'dtsb-button',
            clearAll: 'dtsb-clearAll',
            container: 'dtsb-searchBuilder',
            inputButton: 'dtsb-iptbtn',
            title: 'dtsb-title',
            titleRow: 'dtsb-titleRow'
        };
        SearchBuilder.defaults = {
            filterChanged: undefined,
            preDefined: false
        };
        return SearchBuilder;
    }());

    /*! SearchBuilder 1.0.0
	 * ©2020 SpryMedia Ltd - datatables.net/license/mit
	 */
    // DataTables extensions common UMD. Note that this allows for AMD, CommonJS
    // (with window and jQuery being allowed as parameters to the returned
    // function) or just default browser loading.
    (function (factory) {
        if (typeof define === 'function' && define.amd) {
            // AMD
            define(['jquery', 'datatables.net'], function ($) {
                return factory($, window, document);
            });
        } else if (typeof exports === 'object') {
            // CommonJS
            module.exports = function (root, $) {
                if (!root) {
                    root = window;
                }
                if (!$ || !$.fn.dataTable) {
                    $ = require('datatables.net')(root, $).$;
                }
                return factory($, root, root.document);
            };
        } else {
            // Browser - assume jQuery has already been loaded
            factory(window.jQuery, window, document);
        }
    }(function ($, window, document) {
        setJQuery$2($);
        setJQuery$1($);
        setJQuery($);
        var DataTable = $.fn.dataTable;
        $.fn.dataTable.SearchBuilder = SearchBuilder;
        $.fn.DataTable.SearchBuilder = SearchBuilder;
        $.fn.dataTable.Group = Group;
        $.fn.DataTable.Group = Group;
        $.fn.dataTable.Criteria = Criteria;
        $.fn.DataTable.Criteria = Criteria;
        var apiRegister = $.fn.dataTable.Api.register;
        // Set up object for plugins
        $.fn.dataTable.ext.searchBuilder = {
            conditions: {}
        };
        $.fn.dataTable.ext.buttons.searchBuilder = {
            action: function (e, dt, node, config) {
                e.stopPropagation();
                this.popover(config._searchBuilder.getNode(), {
                    align: 'dt-container'
                });
            },
            config: {},
            init: function (dt, node, config) {
                var sb = new $.fn.dataTable.SearchBuilder(dt, $.extend({
                    filterChanged: function (count) {
                        dt.button(node).text(dt.i18n('searchBuilder.button', {
                            0: 'Search Builder',
                            _: 'Search Builder (%d)'
                        }, count));
                    }
                }, config.config));
                var message = dt.i18n('searchBuilder.button', 'Search Builder', 0);
                dt.button(node).text(message);
                config._searchBuilder = sb;
            },
            text: 'Search Builder'
        };
        apiRegister('searchBuilder.getDetails()', function () {
            var ctx = this.context[0];
            return ctx._searchBuilder.getDetails();
        });
        apiRegister('searchBuilder.rebuild()', function (details) {
            var ctx = this.context[0];
            ctx._searchBuilder.rebuild(details);
            return this;
        });
        apiRegister('searchBuilder.container()', function () {
            var ctx = this.context[0];
            return ctx._searchBuilder.getNode();
        });

        /**
         * Init function for SearchBuilder
         * @param settings the settings to be applied
         * @returns JQUERY<HTMLElement> Returns the node of the SearchBuilder
         */
        function _init(settings) {
            var api = new DataTable.Api(settings);
            var opts = api.init().searchBuilder || DataTable.defaults.searchBuilder;
            var searchBuilder = new SearchBuilder(api, opts);
            var node = searchBuilder.getNode();
            return node;
        }

        // Attach a listener to the document which listens for DataTables initialisation
        // events so we can automatically initialise
        $(document).on('preInit.dt.dtsp', function (e, settings, json) {
            if (e.namespace !== 'dt') {
                return;
            }
            if (settings.oInit.searchBuilder ||
                DataTable.defaults.searchBuilder) {
                if (!settings._searchBuilder) {
                    _init(settings);
                }
            }
        });
        // DataTables `dom` feature option
        DataTable.ext.feature.push({
            cFeature: 'Q',
            fnInit: _init
        });
        // DataTables 2 layout feature
        if (DataTable.ext.features) {
            DataTable.ext.features.register('searchBuilder', _init);
        }
    }));

}());
